feat: organize namespaces

298 files changed, 11279 insertions, 0 deletions

diff --git a/src/WebAssembly/BinaryFormat/Decoder.php b/src/WebAssembly/BinaryFormat/Decoder.php
new file mode 100644
index 0000000..cc408a9
--- /dev/null
+++ b/src/WebAssembly/BinaryFormat/Decoder.php
@@ -0,0 +1,1173 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\BinaryFormat;
+
+use Nsfisis\Waddiwasi\Stream\StreamInterface;
+use Nsfisis\Waddiwasi\WebAssembly\BinaryFormat\Internal\Code;
+use Nsfisis\Waddiwasi\WebAssembly\BinaryFormat\Internal\Locals;
+use Nsfisis\Waddiwasi\WebAssembly\BinaryFormat\Internal\SectionId;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control\BlockType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Data;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\DataMode;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Elem;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ElemMode;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Export;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ExportDesc;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Func;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Global_;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Import;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ImportDesc;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Local;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Mem;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Module;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Start;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Table;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\FuncType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\GlobalType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\Limits;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\MemType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\Mut;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\NumType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\RefType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ResultType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\TableType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\VecType;
+use function array_reduce;
+use function assert;
+use function count;
+use function get_class;
+use function in_array;
+use function is_float;
+use function is_int;
+use function ord;
+
+final class Decoder
+{
+    public function __construct(
+        private readonly StreamInterface $stream,
+    ) {
+    }
+
+    public function decode(): Module
+    {
+        $this->checkMagic();
+        $this->checkVersion();
+
+        $types = $this->decodeSection(SectionId::Type, $this->decodeTypeSecRest(...)) ?? [];
+        $imports = $this->decodeSection(SectionId::Import, $this->decodeImportSecRest(...)) ?? [];
+        $typeIndices = $this->decodeSection(SectionId::Func, $this->decodeFuncSecRest(...)) ?? [];
+        $tables = $this->decodeSection(SectionId::Table, $this->decodeTableSecRest(...)) ?? [];
+        $mems = $this->decodeSection(SectionId::Mem, $this->decodeMemSecRest(...)) ?? [];
+        $globals = $this->decodeSection(SectionId::Global, $this->decodeGlobalSecRest(...)) ?? [];
+        $exports = $this->decodeSection(SectionId::Export, $this->decodeExportSecRest(...)) ?? [];
+        $start = $this->decodeSection(SectionId::Start, $this->decodeStartSecRest(...));
+        $elems = $this->decodeSection(SectionId::Elem, $this->decodeElemSecRest(...)) ?? [];
+        $dataCount = $this->decodeSection(SectionId::DataCount, $this->decodeDataCountSecRest(...));
+        $codes = $this->decodeSection(SectionId::Code, $this->decodeCodeSecRest(...)) ?? [];
+        $datas = $this->decodeSection(SectionId::Data, $this->decodeDataSecRest(...)) ?? [];
+
+        if (!$this->stream->eof()) {
+            throw new InvalidBinaryFormatException("eof");
+        }
+        if ($dataCount === null) {
+            foreach ($codes as $code) {
+                if ($this->countDataIndicesUsedInCode($code) !== 0) {
+                    throw new InvalidBinaryFormatException("datacount section is required");
+                }
+            }
+        } else {
+            if (count($datas) !== $dataCount) {
+                throw new InvalidBinaryFormatException("datasec");
+            }
+        }
+        if (count($typeIndices) !== count($codes)) {
+            throw new InvalidBinaryFormatException("number of funcs and codes does not match");
+        }
+
+        $funcs = [];
+        foreach ($typeIndices as $i => $type) {
+            $code = $codes[$i];
+            $decompressedLocals = array_map(
+                fn ($l) => array_fill(0, $l->count, new Local($l->type)),
+                $code->compressedLocals,
+            );
+            $funcs[] = new Func(
+                $type,
+                array_merge(...$decompressedLocals),
+                $code->body,
+            );
+        }
+
+        return new Module(
+            $types,
+            $funcs,
+            $tables,
+            $mems,
+            $globals,
+            $elems,
+            $datas,
+            $start,
+            $imports,
+            $exports,
+        );
+    }
+
+    private function checkMagic(): void
+    {
+        $bs = $this->stream->read(4);
+        $b1 = ord($bs[0]);
+        $b2 = ord($bs[1]);
+        $b3 = ord($bs[2]);
+        $b4 = ord($bs[3]);
+        if ([$b1, $b2, $b3, $b4] !== [0x00, 0x61, 0x73, 0x6D]) {
+            throw new InvalidBinaryFormatException("magic");
+        }
+    }
+
+    private function checkVersion(): void
+    {
+        $bs = $this->stream->read(4);
+        $b1 = ord($bs[0]);
+        $b2 = ord($bs[1]);
+        $b3 = ord($bs[2]);
+        $b4 = ord($bs[3]);
+        if ([$b1, $b2, $b3, $b4] !== [0x01, 0x00, 0x00, 0x00]) {
+            throw new InvalidBinaryFormatException(sprintf("version: [%x, %x, %x, %x]", $b1, $b2, $b3, $b4));
+        }
+    }
+
+    /**
+     * @template T
+     * @param callable(): T $decoder
+     * @return ?T
+     */
+    private function decodeSection(SectionId $sectionId, callable $decoder): mixed
+    {
+        $this->skipCustomSections();
+        if ($this->stream->eof()) {
+            return null;
+        }
+
+        $idValue = $this->stream->peekByte();
+        $id = SectionId::tryFrom($idValue);
+        if ($id === null) {
+            throw new InvalidBinaryFormatException("section id");
+        }
+        if ($id !== $sectionId) {
+            return null;
+        }
+        $this->stream->seek(1);
+
+        $size = $this->decodeU32();
+        $prevPos = $this->stream->tell();
+        $result = $decoder();
+        if ($this->stream->tell() - $prevPos !== $size) {
+            throw new InvalidBinaryFormatException("type section size");
+        }
+        return $result;
+    }
+
+    private function skipCustomSections(): void
+    {
+        while (!$this->stream->eof()) {
+            $b = $this->stream->peekByte();
+            if ($b !== SectionId::Custom->value) {
+                break;
+            }
+            $this->stream->seek(1);
+            $size = $this->decodeU32();
+            $prevPos = $this->stream->tell();
+            $this->decodeName();
+            $encodedSizeOfName = $this->stream->tell() - $prevPos;
+            $offset = $size - $encodedSizeOfName;
+            if ($offset < 0) {
+                throw new InvalidBinaryFormatException("custom section size");
+            }
+            if ($offset !== 0) {
+                $this->stream->seek($offset);
+            }
+        }
+    }
+
+    /**
+     * @return list<FuncType>
+     */
+    private function decodeTypeSecRest(): array
+    {
+        return $this->decodeVec($this->decodeFuncType(...));
+    }
+
+    /**
+     * @return list<Import>
+     */
+    private function decodeImportSecRest(): array
+    {
+        return $this->decodeVec($this->decodeImport(...));
+    }
+
+    /**
+     * @return list<int>
+     */
+    private function decodeFuncSecRest(): array
+    {
+        return $this->decodeVec($this->decodeTypeIdx(...));
+    }
+
+    /**
+     * @return list<Table>
+     */
+    private function decodeTableSecRest(): array
+    {
+        return $this->decodeVec($this->decodeTable(...));
+    }
+
+    /**
+     * @return list<Mem>
+     */
+    private function decodeMemSecRest(): array
+    {
+        return $this->decodeVec($this->decodeMem(...));
+    }
+
+    /**
+     * @return list<Global_>
+     */
+    private function decodeGlobalSecRest(): array
+    {
+        return $this->decodeVec($this->decodeGlobal(...));
+    }
+
+    /**
+     * @return list<Export>
+     */
+    private function decodeExportSecRest(): array
+    {
+        return $this->decodeVec($this->decodeExport(...));
+    }
+
+    private function decodeStartSecRest(): Start
+    {
+        return new Start($this->decodeFuncIdx());
+    }
+
+    /**
+     * @return list<Elem>
+     */
+    private function decodeElemSecRest(): array
+    {
+        return $this->decodeVec($this->decodeElem(...));
+    }
+
+    /**
+     * @return list<Code>
+     */
+    private function decodeCodeSecRest(): array
+    {
+        return $this->decodeVec($this->decodeCode(...));
+    }
+
+    /**
+     * @return list<Data>
+     */
+    private function decodeDataSecRest(): array
+    {
+        return $this->decodeVec($this->decodeData(...));
+    }
+
+    /**
+     * @return U32
+     */
+    private function decodeDataCountSecRest(): int
+    {
+        return $this->decodeU32();
+    }
+
+    private function decodeResultType(): ResultType
+    {
+        return new ResultType($this->decodeVec($this->decodeValType(...)));
+    }
+
+    private function decodeFuncType(): FuncType
+    {
+        $b = $this->decodeByte();
+        if ($b !== 0x60) {
+            throw new InvalidBinaryFormatException("functype");
+        }
+        $params = $this->decodeResultType();
+        $results = $this->decodeResultType();
+        return new FuncType(
+            $params,
+            $results,
+        );
+    }
+
+    private function decodeValType(): ValType
+    {
+        $b = $this->stream->peekByte();
+        if ($b === 0x7F) {
+            $this->stream->seek(1);
+            return ValType::NumType(NumType::I32);
+        } elseif ($b === 0x7E) {
+            $this->stream->seek(1);
+            return ValType::NumType(NumType::I64);
+        } elseif ($b === 0x7D) {
+            $this->stream->seek(1);
+            return ValType::NumType(NumType::F32);
+        } elseif ($b === 0x7C) {
+            $this->stream->seek(1);
+            return ValType::NumType(NumType::F64);
+        } elseif ($b === 0x7B) {
+            $this->stream->seek(1);
+            return ValType::VecType(VecType::V128);
+        } else {
+            return ValType::RefType($this->decodeRefType());
+        }
+    }
+
+    private function decodeRefType(): RefType
+    {
+        return match ($this->decodeByte()) {
+            0x70 => RefType::FuncRef,
+            0x6F => RefType::ExternRef,
+            default => throw new InvalidBinaryFormatException("reftype"),
+        };
+    }
+
+    private function decodeLimits(): Limits
+    {
+        $b = $this->decodeByte();
+        if ($b === 0x00) {
+            $min = $this->decodeU32();
+            return new Limits($min, null);
+        } elseif ($b === 0x01) {
+            $min = $this->decodeU32();
+            $max = $this->decodeU32();
+            return new Limits($min, $max);
+        } else {
+            throw new InvalidBinaryFormatException("limits");
+        }
+    }
+
+    private function decodeMemType(): MemType
+    {
+        return new MemType($this->decodeLimits());
+    }
+
+    private function decodeTableType(): TableType
+    {
+        $refType = $this->decodeRefType();
+        $limits = $this->decodeLimits();
+        return new TableType(
+            $limits,
+            $refType,
+        );
+    }
+
+    private function decodeGlobalType(): GlobalType
+    {
+        $valType = $this->decodeValType();
+        $mut = $this->decodeMut();
+        return new GlobalType(
+            $mut,
+            $valType,
+        );
+    }
+
+    private function decodeMut(): Mut
+    {
+        return match ($this->decodeByte()) {
+            0x00 => Mut::Const,
+            0x01 => Mut::Var,
+            default => throw new InvalidBinaryFormatException("mutability"),
+        };
+    }
+
+    private function decodeImport(): Import
+    {
+        $module = $this->decodeName();
+        $name = $this->decodeName();
+        $desc = $this->decodeImportDesc();
+        return new Import(
+            $module,
+            $name,
+            $desc,
+        );
+    }
+
+    private function decodeTable(): Table
+    {
+        return new Table($this->decodeTableType());
+    }
+
+    private function decodeMem(): Mem
+    {
+        return new Mem($this->decodeMemType());
+    }
+
+    private function decodeGlobal(): Global_
+    {
+        $type = $this->decodeGlobalType();
+        $init = $this->decodeExpr();
+        return new Global_(
+            $type,
+            $init,
+        );
+    }
+
+    private function decodeExport(): Export
+    {
+        $name = $this->decodeName();
+        $desc = $this->decodeExportDesc();
+        return new Export(
+            $name,
+            $desc,
+        );
+    }
+
+    private function decodeElem(): Elem
+    {
+        $mode = $this->decodeU32();
+        if ($mode === 0) {
+            $offset = $this->decodeExpr();
+            $initFuncRefs = $this->decodeVec($this->decodeFuncIdx(...));
+            return new Elem(
+                RefType::FuncRef,
+                array_map(
+                    fn ($funcRef) => [Instr::RefFunc($funcRef)],
+                    $initFuncRefs,
+                ),
+                ElemMode::Active(0, $offset),
+            );
+        } elseif ($mode === 1) {
+            $refType = $this->decodeElemKind();
+            $initFuncRefs = $this->decodeVec($this->decodeFuncIdx(...));
+            return new Elem(
+                $refType,
+                array_map(
+                    fn ($funcRef) => [Instr::RefFunc($funcRef)],
+                    $initFuncRefs,
+                ),
+                ElemMode::Passive(),
+            );
+        } elseif ($mode === 2) {
+            $table = $this->decodeTableIdx();
+            $offset = $this->decodeExpr();
+            $refType = $this->decodeElemKind();
+            $initFuncRefs = $this->decodeVec($this->decodeFuncIdx(...));
+            return new Elem(
+                $refType,
+                array_map(
+                    fn ($funcRef) => [Instr::RefFunc($funcRef)],
+                    $initFuncRefs,
+                ),
+                ElemMode::Active($table, $offset),
+            );
+        } elseif ($mode === 3) {
+            $refType = $this->decodeElemKind();
+            $initFuncRefs = $this->decodeVec($this->decodeFuncIdx(...));
+            return new Elem(
+                $refType,
+                array_map(
+                    fn ($funcRef) => [Instr::RefFunc($funcRef)],
+                    $initFuncRefs,
+                ),
+                ElemMode::Declarative(),
+            );
+        } elseif ($mode === 4) {
+            $offset = $this->decodeExpr();
+            $init = $this->decodeVec($this->decodeExpr(...));
+            return new Elem(
+                RefType::FuncRef,
+                $init,
+                ElemMode::Active(0, $offset),
+            );
+        } elseif ($mode === 5) {
+            $refType = $this->decodeRefType();
+            $init = $this->decodeVec($this->decodeExpr(...));
+            return new Elem(
+                $refType,
+                $init,
+                ElemMode::Passive(),
+            );
+        } elseif ($mode === 6) {
+            $table = $this->decodeTableIdx();
+            $offset = $this->decodeExpr();
+            $refType = $this->decodeRefType();
+            $init = $this->decodeVec($this->decodeExpr(...));
+            return new Elem(
+                $refType,
+                $init,
+                ElemMode::Active($table, $offset),
+            );
+        } elseif ($mode === 7) {
+            $refType = $this->decodeRefType();
+            $init = $this->decodeVec($this->decodeExpr(...));
+            return new Elem(
+                $refType,
+                $init,
+                ElemMode::Declarative(),
+            );
+        } else {
+            throw new InvalidBinaryFormatException("code");
+        }
+    }
+
+    private function decodeCode(): Code
+    {
+        $size = $this->decodeU32();
+        $prevPos = $this->stream->tell();
+        $compressedLocals = $this->decodeVec($this->decodeLocals(...));
+        $body = $this->decodeExpr();
+        if ($this->stream->tell() - $prevPos !== $size) {
+            throw new InvalidBinaryFormatException("code size");
+        }
+        return new Code(
+            $compressedLocals,
+            $body,
+        );
+    }
+
+    private function decodeData(): Data
+    {
+        $mode = $this->decodeU32();
+        if ($mode === 0) {
+            $offset = $this->decodeExpr();
+            $init = $this->decodeVec($this->decodeByte(...));
+            return new Data(
+                $init,
+                DataMode::Active(
+                    0,
+                    $offset,
+                ),
+            );
+        } elseif ($mode === 1) {
+            $init = $this->decodeVec($this->decodeByte(...));
+            return new Data(
+                $init,
+                DataMode::Passive(),
+            );
+        } elseif ($mode === 2) {
+            $memory = $this->decodeMemIdx();
+            $offset = $this->decodeExpr();
+            $init = $this->decodeVec($this->decodeByte(...));
+            return new Data(
+                $init,
+                DataMode::Active(
+                    $memory,
+                    $offset,
+                ),
+            );
+        } else {
+            throw new InvalidBinaryFormatException("data");
+        }
+    }
+
+    private function decodeImportDesc(): ImportDesc
+    {
+        return match ($this->decodeByte()) {
+            0x00 => ImportDesc::Func($this->decodeTypeIdx()),
+            0x01 => ImportDesc::Table($this->decodeTableType()),
+            0x02 => ImportDesc::Mem($this->decodeMemType()),
+            0x03 => ImportDesc::Global($this->decodeGlobalType()),
+            default => throw new InvalidBinaryFormatException("importdesc"),
+        };
+    }
+
+    private function decodeExportDesc(): ExportDesc
+    {
+        return match ($this->decodeByte()) {
+            0x00 => ExportDesc::Func($this->decodeFuncIdx()),
+            0x01 => ExportDesc::Table($this->decodeTableIdx()),
+            0x02 => ExportDesc::Mem($this->decodeMemIdx()),
+            0x03 => ExportDesc::Global($this->decodeGlobalIdx()),
+            default => throw new InvalidBinaryFormatException("exportdesc"),
+        };
+    }
+
+    private function decodeElemKind(): RefType
+    {
+        $b = $this->decodeByte();
+        if ($b === 0x00) {
+            return RefType::FuncRef;
+        } else {
+            throw new InvalidBinaryFormatException("elemkind");
+        }
+    }
+
+    private function decodeLocals(): Locals
+    {
+        $count = $this->decodeU32();
+        // @todo Provide a way to configure the limit.
+        if (1024 < $count) {
+            throw new InvalidBinaryFormatException("too many local variables");
+        }
+        $type = $this->decodeValType();
+        return new Locals(
+            $count,
+            $type,
+        );
+    }
+
+    private function decodeTypeIdx(): int
+    {
+        return $this->decodeU32();
+    }
+
+    private function decodeMemIdx(): int
+    {
+        return $this->decodeU32();
+    }
+
+    private function decodeFuncIdx(): int
+    {
+        return $this->decodeU32();
+    }
+
+    private function decodeTableIdx(): int
+    {
+        return $this->decodeU32();
+    }
+
+    private function decodeGlobalIdx(): int
+    {
+        return $this->decodeU32();
+    }
+
+    private function decodeLocalIdx(): int
+    {
+        return $this->decodeU32();
+    }
+
+    private function decodeLabelIdx(): int
+    {
+        return $this->decodeU32();
+    }
+
+    private function decodeDataIdx(): int
+    {
+        return $this->decodeU32();
+    }
+
+    private function decodeElemIdx(): int
+    {
+        return $this->decodeU32();
+    }
+
+    /**
+     * @return list<Instr>
+     */
+    private function decodeExpr(): array
+    {
+        return $this->decodeInstrsUntil([Instrs\Control\End::class])[0];
+    }
+
+    private function decodeInstr(): Instr
+    {
+        switch ($op = $this->decodeByte()) {
+            case 0x00: return Instr::Unreachable();
+            case 0x01: return Instr::Nop();
+            case 0x02:
+                $blockType = $this->decodeBlockType();
+                $body = $this->decodeInstrsUntil([Instrs\Control\End::class])[0];
+                return Instr::Block($blockType, $body);
+            case 0x03:
+                $blockType = $this->decodeBlockType();
+                $body = $this->decodeInstrsUntil([Instrs\Control\End::class])[0];
+                return Instr::Loop($blockType, $body);
+            case 0x04:
+                $blockType = $this->decodeBlockType();
+                [$thenBody, $delimiter] = $this->decodeInstrsUntil([Instrs\Control\End::class, Instrs\Control\Else_::class]);
+                if ($delimiter instanceof Instrs\Control\End) {
+                    return Instr::If_($blockType, $thenBody, []);
+                }
+                $elseBody = $this->decodeInstrsUntil([Instrs\Control\End::class])[0];
+                return Instr::If_($blockType, $thenBody, $elseBody);
+            case 0x05: return Instr::Else_();
+            case 0x0B: return Instr::End();
+            case 0x0C: return Instr::Br($this->decodeLabelIdx());
+            case 0x0D: return Instr::BrIf($this->decodeLabelIdx());
+            case 0x0E:
+                $labelTable = $this->decodeVec($this->decodeLabelIdx(...));
+                $defaultLabel = $this->decodeLabelIdx();
+                return Instr::BrTable($labelTable, $defaultLabel);
+            case 0x0F: return Instr::Return_();
+            case 0x10: return Instr::Call($this->decodeFuncIdx());
+            case 0x11:
+                $type = $this->decodeTypeIdx();
+                $funcTable = $this->decodeTableIdx();
+                return Instr::CallIndirect($funcTable, $type);
+            case 0x1A: return Instr::Drop();
+            case 0x1B: return Instr::Select([]);
+            case 0x1C: return Instr::Select($this->decodeVec($this->decodeValType(...)));
+            case 0x20: return Instr::LocalGet($this->decodeLocalIdx());
+            case 0x21: return Instr::LocalSet($this->decodeLocalIdx());
+            case 0x22: return Instr::LocalTee($this->decodeLocalIdx());
+            case 0x23: return Instr::GlobalGet($this->decodeGlobalIdx());
+            case 0x24: return Instr::GlobalSet($this->decodeGlobalIdx());
+            case 0x25: return Instr::TableGet($this->decodeTableIdx());
+            case 0x26: return Instr::TableSet($this->decodeTableIdx());
+            case 0x28: return Instr::I32Load(...$this->decodeMemArg());
+            case 0x29: return Instr::I64Load(...$this->decodeMemArg());
+            case 0x2A: return Instr::F32Load(...$this->decodeMemArg());
+            case 0x2B: return Instr::F64Load(...$this->decodeMemArg());
+            case 0x2C: return Instr::I32Load8S(...$this->decodeMemArg());
+            case 0x2D: return Instr::I32Load8U(...$this->decodeMemArg());
+            case 0x2E: return Instr::I32Load16S(...$this->decodeMemArg());
+            case 0x2F: return Instr::I32Load16U(...$this->decodeMemArg());
+            case 0x30: return Instr::I64Load8S(...$this->decodeMemArg());
+            case 0x31: return Instr::I64Load8U(...$this->decodeMemArg());
+            case 0x32: return Instr::I64Load16S(...$this->decodeMemArg());
+            case 0x33: return Instr::I64Load16U(...$this->decodeMemArg());
+            case 0x34: return Instr::I64Load32S(...$this->decodeMemArg());
+            case 0x35: return Instr::I64Load32U(...$this->decodeMemArg());
+            case 0x36: return Instr::I32Store(...$this->decodeMemArg());
+            case 0x37: return Instr::I64Store(...$this->decodeMemArg());
+            case 0x38: return Instr::F32Store(...$this->decodeMemArg());
+            case 0x39: return Instr::F64Store(...$this->decodeMemArg());
+            case 0x3A: return Instr::I32Store8(...$this->decodeMemArg());
+            case 0x3B: return Instr::I32Store16(...$this->decodeMemArg());
+            case 0x3C: return Instr::I64Store8(...$this->decodeMemArg());
+            case 0x3D: return Instr::I64Store16(...$this->decodeMemArg());
+            case 0x3E: return Instr::I64Store32(...$this->decodeMemArg());
+            case 0x3F:
+                $c = $this->decodeByte();
+                if ($c !== 0) {
+                    throw new InvalidBinaryFormatException("Unexpected value while decoding an instruction `memory.size`, expected 0, but got $c");
+                }
+                return Instr::MemorySize();
+            case 0x40:
+                $c = $this->decodeByte();
+                if ($c !== 0) {
+                    throw new InvalidBinaryFormatException("Unexpected value while decoding an instruction `memory.grow`, expected 0, but got $c");
+                }
+                return Instr::MemoryGrow();
+            case 0x41: return Instr::I32Const($this->decodeS32());
+            case 0x42: return Instr::I64Const($this->decodeS64());
+            case 0x43: return Instr::F32Const($this->decodeF32());
+            case 0x44: return Instr::F64Const($this->decodeF64());
+            case 0x45: return Instr::I32Eqz();
+            case 0x46: return Instr::I32Eq();
+            case 0x47: return Instr::I32Ne();
+            case 0x48: return Instr::I32LtS();
+            case 0x49: return Instr::I32LtU();
+            case 0x4A: return Instr::I32GtS();
+            case 0x4B: return Instr::I32GtU();
+            case 0x4C: return Instr::I32LeS();
+            case 0x4D: return Instr::I32LeU();
+            case 0x4E: return Instr::I32GeS();
+            case 0x4F: return Instr::I32GeU();
+            case 0x50: return Instr::I64Eqz();
+            case 0x51: return Instr::I64Eq();
+            case 0x52: return Instr::I64Ne();
+            case 0x53: return Instr::I64LtS();
+            case 0x54: return Instr::I64LtU();
+            case 0x55: return Instr::I64GtS();
+            case 0x56: return Instr::I64GtU();
+            case 0x57: return Instr::I64LeS();
+            case 0x58: return Instr::I64LeU();
+            case 0x59: return Instr::I64GeS();
+            case 0x5A: return Instr::I64GeU();
+            case 0x5B: return Instr::F32Eq();
+            case 0x5C: return Instr::F32Ne();
+            case 0x5D: return Instr::F32Lt();
+            case 0x5E: return Instr::F32Gt();
+            case 0x5F: return Instr::F32Le();
+            case 0x60: return Instr::F32Ge();
+            case 0x61: return Instr::F64Eq();
+            case 0x62: return Instr::F64Ne();
+            case 0x63: return Instr::F64Lt();
+            case 0x64: return Instr::F64Gt();
+            case 0x65: return Instr::F64Le();
+            case 0x66: return Instr::F64Ge();
+            case 0x67: return Instr::I32Clz();
+            case 0x68: return Instr::I32Ctz();
+            case 0x69: return Instr::I32Popcnt();
+            case 0x6A: return Instr::I32Add();
+            case 0x6B: return Instr::I32Sub();
+            case 0x6C: return Instr::I32Mul();
+            case 0x6D: return Instr::I32DivS();
+            case 0x6E: return Instr::I32DivU();
+            case 0x6F: return Instr::I32RemS();
+            case 0x70: return Instr::I32RemU();
+            case 0x71: return Instr::I32And();
+            case 0x72: return Instr::I32Or();
+            case 0x73: return Instr::I32Xor();
+            case 0x74: return Instr::I32Shl();
+            case 0x75: return Instr::I32ShrS();
+            case 0x76: return Instr::I32ShrU();
+            case 0x77: return Instr::I32RotL();
+            case 0x78: return Instr::I32RotR();
+            case 0x79: return Instr::I64Clz();
+            case 0x7A: return Instr::I64Ctz();
+            case 0x7B: return Instr::I64Popcnt();
+            case 0x7C: return Instr::I64Add();
+            case 0x7D: return Instr::I64Sub();
+            case 0x7E: return Instr::I64Mul();
+            case 0x7F: return Instr::I64DivS();
+            case 0x80: return Instr::I64DivU();
+            case 0x81: return Instr::I64RemS();
+            case 0x82: return Instr::I64RemU();
+            case 0x83: return Instr::I64And();
+            case 0x84: return Instr::I64Or();
+            case 0x85: return Instr::I64Xor();
+            case 0x86: return Instr::I64Shl();
+            case 0x87: return Instr::I64ShrS();
+            case 0x88: return Instr::I64ShrU();
+            case 0x89: return Instr::I64RotL();
+            case 0x8A: return Instr::I64RotR();
+            case 0x8B: return Instr::F32Abs();
+            case 0x8C: return Instr::F32Neg();
+            case 0x8D: return Instr::F32Ceil();
+            case 0x8E: return Instr::F32Floor();
+            case 0x8F: return Instr::F32Trunc();
+            case 0x90: return Instr::F32Nearest();
+            case 0x91: return Instr::F32Sqrt();
+            case 0x92: return Instr::F32Add();
+            case 0x93: return Instr::F32Sub();
+            case 0x94: return Instr::F32Mul();
+            case 0x95: return Instr::F32Div();
+            case 0x96: return Instr::F32Min();
+            case 0x97: return Instr::F32Max();
+            case 0x98: return Instr::F32CopySign();
+            case 0x99: return Instr::F64Abs();
+            case 0x9A: return Instr::F64Neg();
+            case 0x9B: return Instr::F64Ceil();
+            case 0x9C: return Instr::F64Floor();
+            case 0x9D: return Instr::F64Trunc();
+            case 0x9E: return Instr::F64Nearest();
+            case 0x9F: return Instr::F64Sqrt();
+            case 0xA0: return Instr::F64Add();
+            case 0xA1: return Instr::F64Sub();
+            case 0xA2: return Instr::F64Mul();
+            case 0xA3: return Instr::F64Div();
+            case 0xA4: return Instr::F64Min();
+            case 0xA5: return Instr::F64Max();
+            case 0xA6: return Instr::F64CopySign();
+            case 0xA7: return Instr::I32WrapI64();
+            case 0xA8: return Instr::I32TruncF32S();
+            case 0xA9: return Instr::I32TruncF32U();
+            case 0xAA: return Instr::I32TruncF64S();
+            case 0xAB: return Instr::I32TruncF64U();
+            case 0xAC: return Instr::I64ExtendI32S();
+            case 0xAD: return Instr::I64ExtendI32U();
+            case 0xAE: return Instr::I64TruncF32S();
+            case 0xAF: return Instr::I64TruncF32U();
+            case 0xB0: return Instr::I64TruncF64S();
+            case 0xB1: return Instr::I64TruncF64U();
+            case 0xB2: return Instr::F32ConvertI32S();
+            case 0xB3: return Instr::F32ConvertI32U();
+            case 0xB4: return Instr::F32ConvertI64S();
+            case 0xB5: return Instr::F32ConvertI64U();
+            case 0xB6: return Instr::F32DemoteF64();
+            case 0xB7: return Instr::F64ConvertI32S();
+            case 0xB8: return Instr::F64ConvertI32U();
+            case 0xB9: return Instr::F64ConvertI64S();
+            case 0xBA: return Instr::F64ConvertI64U();
+            case 0xBB: return Instr::F64PromoteF32();
+            case 0xBC: return Instr::I32ReinterpretF32();
+            case 0xBD: return Instr::I64ReinterpretF64();
+            case 0xBE: return Instr::F32ReinterpretI32();
+            case 0xBF: return Instr::F64ReinterpretI64();
+            case 0xC0: return Instr::I32Extend8S();
+            case 0xC1: return Instr::I32Extend16S();
+            case 0xC2: return Instr::I64Extend8S();
+            case 0xC3: return Instr::I64Extend16S();
+            case 0xC4: return Instr::I64Extend32S();
+            case 0xD0: return Instr::RefNull($this->decodeRefType());
+            case 0xD1: return Instr::RefIsNull();
+            case 0xD2: return Instr::RefFunc($this->decodeFuncIdx());
+            case 0xFC:
+                switch ($this->decodeU32()) {
+                    case 0: return Instr::I32TruncSatF32S();
+                    case 1: return Instr::I32TruncSatF32U();
+                    case 2: return Instr::I32TruncSatF64S();
+                    case 3: return Instr::I32TruncSatF64U();
+                    case 4: return Instr::I64TruncSatF32S();
+                    case 5: return Instr::I64TruncSatF32U();
+                    case 6: return Instr::I64TruncSatF64S();
+                    case 7: return Instr::I64TruncSatF64U();
+                    case 8:
+                        $data = $this->decodeDataIdx();
+                        if ($this->decodeByte() !== 0) {
+                            throw new InvalidBinaryFormatException("memory init");
+                        }
+                        return Instr::MemoryInit($data);
+                    case 9: return Instr::DataDrop($this->decodeDataIdx());
+                    case 10:
+                        if ($this->decodeByte() !== 0) {
+                            throw new InvalidBinaryFormatException("memory copy");
+                        }
+                        if ($this->decodeByte() !== 0) {
+                            throw new InvalidBinaryFormatException("memory copy");
+                        }
+                        return Instr::MemoryCopy();
+                    case 11:
+                        if ($this->decodeByte() !== 0) {
+                            throw new InvalidBinaryFormatException("memory fill");
+                        }
+                        return Instr::MemoryFill();
+                    case 12:
+                        $from = $this->decodeElemIdx();
+                        $to = $this->decodeTableIdx();
+                        return Instr::TableInit($to, $from);
+                    case 13: return Instr::ElemDrop($this->decodeElemIdx());
+                    case 14:
+                        $to = $this->decodeTableIdx();
+                        $from = $this->decodeTableIdx();
+                        return Instr::TableCopy($to, $from);
+                    case 15: return Instr::TableGrow($this->decodeTableIdx());
+                    case 16: return Instr::TableSize($this->decodeTableIdx());
+                    case 17: return Instr::TableFill($this->decodeTableIdx());
+                    default:
+                        throw new InvalidBinaryFormatException("instr");
+                }
+                // no break
+            default:
+                throw new InvalidBinaryFormatException("Unexpected opcode $op while decoding an instruction");
+        }
+    }
+
+    /**
+     * @return array{0: U32, 1: U32}
+     */
+    private function decodeMemArg(): array
+    {
+        $align = $this->decodeU32();
+        $offset = $this->decodeU32();
+        return [$offset, $align];
+    }
+
+    private function decodeBlockType(): BlockType
+    {
+        $b = $this->stream->peekByte();
+        if ($b === 0x40) {
+            $this->stream->seek(1);
+            return BlockType::ValType(null);
+        } elseif (in_array($b, [0x7F, 0x7E, 0x7D, 0x7C, 0x7B, 0x70, 0x6F], true)) {
+            return BlockType::ValType($this->decodeValType());
+        } else {
+            $type = $this->decodeS33();
+            if ($type < 0) {
+                throw new InvalidBinaryFormatException("blocktype");
+            }
+            return BlockType::TypeIdx($type);
+        }
+    }
+
+    /**
+     * @param list<class-string<Instr>> $delimiters
+     * @return array{0: list<Instr>, 1: Instr}
+     */
+    private function decodeInstrsUntil(array $delimiters): array
+    {
+        $result = [];
+        while (true) {
+            $instr = $this->decodeInstr();
+            if (in_array(get_class($instr), $delimiters, true)) {
+                return [$result, $instr];
+            }
+            $result[] = $instr;
+        }
+    }
+
+    /**
+     * @template T
+     * @param callable(): T $decoder
+     * @return list<T>
+     */
+    private function decodeVec(callable $decoder): array
+    {
+        $count = $this->decodeU32();
+        $result = [];
+        for ($i = 0; $i < $count; $i++) {
+            $result[] = $decoder();
+        }
+        return $result;
+    }
+
+    /**
+     * @phpstan-impure
+     */
+    private function decodeByte(): int
+    {
+        return $this->stream->readByte();
+    }
+
+    private function decodeU32(): int
+    {
+        return $this->decodeUnsignedLeb128(32);
+    }
+
+    private function decodeUnsignedLeb128(int $maxBits): int
+    {
+        $result = 0;
+        for ($shiftBits = 0; $shiftBits < $maxBits; $shiftBits += 7) {
+            $b = $this->decodeByte();
+            $leftBitsCount = $maxBits - $shiftBits;
+            if ($leftBitsCount < 7) {
+                if ((($b & 0b01111111) >> $leftBitsCount) !== 0) {
+                    throw new InvalidBinaryFormatException("unsigned leb128 ($maxBits): too large");
+                }
+            }
+            $result |= ($b & 0b01111111) << $shiftBits;
+            if (($b & 0b10000000) === 0) {
+                return $result;
+            }
+        }
+        throw new InvalidBinaryFormatException("unsigned leb128 ($maxBits): too large");
+    }
+
+    private function decodeSignedLeb128(int $maxBits): int
+    {
+        $result = 0;
+        for ($shiftBits = 0; $shiftBits < $maxBits; $shiftBits += 7) {
+            $b = $this->decodeByte();
+            $leftBitsCount = $maxBits - $shiftBits;
+            if ($leftBitsCount < 7) {
+                if (($b & (1 << ($leftBitsCount - 1))) === 0) {
+                    if ((($b & 0b01111111) >> $leftBitsCount) !== 0) {
+                        throw new InvalidBinaryFormatException("signed leb128 ($maxBits): too large");
+                    }
+                } else {
+                    if ((($b & 0b01111111) >> $leftBitsCount) + 1 !== (1 << (7 - $leftBitsCount))) {
+                        throw new InvalidBinaryFormatException("signed leb128 ($maxBits): too large");
+                    }
+                }
+            }
+            $result |= ($b & 0b01111111) << $shiftBits;
+            if (($b & 0b10000000) === 0) {
+                if (($b & 0b01000000) === 0) {
+                    return $result;
+                } else {
+                    return $result | (~0 << ($shiftBits + 7));
+                }
+            }
+        }
+        throw new InvalidBinaryFormatException("signed leb128 ($maxBits): too large");
+    }
+
+    /**
+     * @return S32
+     */
+    private function decodeS32(): int
+    {
+        return $this->decodeSignedLeb128(32);
+    }
+
+    /**
+     * @return S33
+     */
+    private function decodeS33(): int
+    {
+        return $this->decodeSignedLeb128(33);
+    }
+
+    /**
+     * @return S64
+     */
+    private function decodeS64(): int
+    {
+        return $this->decodeSignedLeb128(64);
+    }
+
+    /**
+     * @return F32
+     */
+    private function decodeF32(): float
+    {
+        $buf = $this->stream->read(4);
+        $result = unpack('g', $buf);
+        if ($result === false) {
+            throw new InvalidBinaryFormatException("f32");
+        }
+        assert(isset($result[1]) && is_float($result[1]));
+        return $result[1];
+    }
+
+    /**
+     * @return F64
+     */
+    private function decodeF64(): float
+    {
+        $buf = $this->stream->read(8);
+        $result = unpack('e', $buf);
+        if ($result === false) {
+            throw new InvalidBinaryFormatException("f64");
+        }
+        assert(isset($result[1]) && is_float($result[1]));
+        return $result[1];
+    }
+
+    /**
+     * @return Name
+     */
+    private function decodeName(): string
+    {
+        $bytes = $this->decodeVec($this->decodeByte(...));
+        $name = $this->implodeUtf8BytesToString($bytes);
+        if ($name === null) {
+            throw new InvalidBinaryFormatException("name");
+        }
+        return $name;
+    }
+
+    /**
+     * @param list<int> $bytes
+     */
+    private function implodeUtf8BytesToString(array $bytes): ?string
+    {
+        $s = '';
+        $count = count($bytes);
+        for ($i = 0; $i < $count; $i++) {
+            if (($bytes[$i] & 0x80) === 0) {
+                $code = $bytes[$i];
+            } elseif (($bytes[$i] & 0xE0) === 0xC0) {
+                if ($count <= $i + 1) {
+                    return null;
+                }
+                $code = (($bytes[$i] & 0x1F) << 6) | ($bytes[$i + 1] & 0x3F);
+                $i++;
+            } elseif (($bytes[$i] & 0xF0) === 0xE0) {
+                if ($count <= $i + 2) {
+                    return null;
+                }
+                $code = (($bytes[$i] & 0x0F) << 12) | (($bytes[$i + 1] & 0x3F) << 6) | ($bytes[$i + 2] & 0x3F);
+                $i += 2;
+            } elseif (($bytes[$i] & 0xF8) === 0xF0) {
+                if ($count <= $i + 3) {
+                    return null;
+                }
+                $code = (($bytes[$i] & 0x07) << 18) | (($bytes[$i + 1] & 0x3F) << 12) | (($bytes[$i + 2] & 0x3F) << 6) | ($bytes[$i + 3] & 0x3F);
+                $i += 3;
+            } else {
+                return null;
+            }
+            $s .= mb_chr($code, 'UTF-8');
+        }
+        return $s;
+    }
+
+    /**
+     * @return 0|positive-int
+     */
+    private function countDataIndicesUsedInCode(Code $code): int
+    {
+        $result = array_reduce(
+            $code->body,
+            fn ($acc, $instr) => $acc + match ($instr::class) {
+                Instrs\Memory\DataDrop::class => 1,
+                Instrs\Memory\MemoryInit::class => 1,
+                default => 0,
+            },
+            0,
+        );
+        assert(is_int($result), '$result is guaranteed not to exceed the maximum value of an integer because the number of instructions in $code is limited');
+        assert(0 <= $result, '$result is guaranteed to be non-negative because it is the sum of non-negative integers');
+        return $result;
+    }
+}
diff --git a/src/WebAssembly/BinaryFormat/Internal/Code.php b/src/WebAssembly/BinaryFormat/Internal/Code.php
new file mode 100644
index 0000000..80010e2
--- /dev/null
+++ b/src/WebAssembly/BinaryFormat/Internal/Code.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\BinaryFormat\Internal;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+/**
+ * @internal
+ */
+final readonly class Code
+{
+    /**
+     * @param list<Locals> $compressedLocals
+     * @param list<Instr> $body
+     */
+    public function __construct(
+        public array $compressedLocals,
+        public array $body,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/BinaryFormat/Internal/Locals.php b/src/WebAssembly/BinaryFormat/Internal/Locals.php
new file mode 100644
index 0000000..7cc0029
--- /dev/null
+++ b/src/WebAssembly/BinaryFormat/Internal/Locals.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\BinaryFormat\Internal;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValType;
+
+/**
+ * @internal
+ */
+final readonly class Locals
+{
+    /**
+     * @param U32 $count
+     */
+    public function __construct(
+        public int $count,
+        public ValType $type,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/BinaryFormat/Internal/SectionId.php b/src/WebAssembly/BinaryFormat/Internal/SectionId.php
new file mode 100644
index 0000000..e085c37
--- /dev/null
+++ b/src/WebAssembly/BinaryFormat/Internal/SectionId.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\BinaryFormat\Internal;
+
+/**
+ * @internal
+ */
+enum SectionId: int
+{
+    case Custom = 0;
+    case Type = 1;
+    case Import = 2;
+    case Func = 3;
+    case Table = 4;
+    case Mem = 5;
+    case Global = 6;
+    case Export = 7;
+    case Start = 8;
+    case Elem = 9;
+    case Code = 10;
+    case Data = 11;
+    case DataCount = 12;
+}
diff --git a/src/WebAssembly/BinaryFormat/InvalidBinaryFormatException.php b/src/WebAssembly/BinaryFormat/InvalidBinaryFormatException.php
new file mode 100644
index 0000000..b6b670c
--- /dev/null
+++ b/src/WebAssembly/BinaryFormat/InvalidBinaryFormatException.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\BinaryFormat;
+
+use RuntimeException;
+
+class InvalidBinaryFormatException extends RuntimeException
+{
+}
diff --git a/src/WebAssembly/Debug/Debug.php b/src/WebAssembly/Debug/Debug.php
new file mode 100644
index 0000000..738dff2
--- /dev/null
+++ b/src/WebAssembly/Debug/Debug.php
@@ -0,0 +1,112 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Debug;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ImportDescs;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Module;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\FuncType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\GlobalType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\Limits;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\MemType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\Mut;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\NumType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\RefType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ResultType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\TableType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValTypes;
+
+final readonly class Debug
+{
+    public static function printImports(Module $module): void
+    {
+        foreach ($module->imports as $import) {
+            $mod = $import->module;
+            $name = $import->name;
+            $desc = $import->desc;
+            $type = match ($desc::class) {
+                ImportDescs\Func::class => 'func',
+                ImportDescs\Table::class => 'table',
+                ImportDescs\Mem::class => 'mem',
+                ImportDescs\Global_::class => 'global',
+                default => 'unknown',
+            };
+            $extraInfo = match ($desc::class) {
+                ImportDescs\Func::class => self::typeIdxToString($desc->func, $module),
+                ImportDescs\Table::class => self::tableTypeToString($desc->table),
+                ImportDescs\Mem::class => self::memTypeToString($desc->mem),
+                ImportDescs\Global_::class => self::globalTypeToString($desc->global),
+                default => 'unknown',
+            };
+            echo "$mod::$name: $type $extraInfo\n";
+        }
+    }
+
+    private static function typeIdxToString(int $idx, Module $module): string
+    {
+        $type = $module->types[$idx];
+        return self::funcTypeToString($type);
+    }
+
+    private static function tableTypeToString(TableType $type): string
+    {
+        return self::valTypeToString(ValType::RefType($type->refType)) . ' ' . self::limitsToString($type->limits);
+    }
+
+    private static function memTypeToString(MemType $type): string
+    {
+        return self::limitsToString($type->limits);
+    }
+
+    private static function globalTypeToString(GlobalType $type): string
+    {
+        return self::mutToString($type->mut) . ' ' . self::valTypeToString($type->valType);
+    }
+
+    private static function funcTypeToString(FuncType $type): string
+    {
+        $params = self::resultTypeToString($type->params);
+        $results = self::resultTypeToString($type->results);
+        return "($params) -> ($results)";
+    }
+
+    private static function valTypeToString(ValType $type): string
+    {
+        return match ($type::class) {
+            ValTypes\NumType::class => match ($type->inner) {
+                NumType::I32 => 'i32',
+                NumType::I64 => 'i64',
+                NumType::F32 => 'f32',
+                NumType::F64 => 'f64',
+            },
+            ValTypes\VecType::class => 'v128',
+            ValTypes\RefType::class => match ($type->inner) {
+                RefType::FuncRef => 'funcref',
+                RefType::ExternRef => 'externref',
+            },
+            default => 'unknown',
+        };
+    }
+
+    private static function limitsToString(Limits $limit): string
+    {
+        $min = $limit->min;
+        $max = $limit->max;
+        return $max === null ? "[$min, inf)" : "[$min, $max]";
+    }
+
+    private static function mutToString(Mut $mut): string
+    {
+        return match ($mut) {
+            Mut::Const => 'const',
+            Mut::Var => 'var',
+        };
+    }
+
+    private static function resultTypeToString(ResultType $type): string
+    {
+        return implode(', ', array_map(self::valTypeToString(...), $type->types));
+    }
+}
diff --git a/src/WebAssembly/Execution/Allocator.php b/src/WebAssembly/Execution/Allocator.php
new file mode 100644
index 0000000..67eb467
--- /dev/null
+++ b/src/WebAssembly/Execution/Allocator.php
@@ -0,0 +1,165 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ExportDescs;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Func;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Module;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\GlobalType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\MemType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\RefType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\TableType;
+use RuntimeException;
+use function count;
+
+final readonly class Allocator
+{
+    public function __construct(
+        private readonly Store $store,
+    ) {
+    }
+
+    /**
+     * @param list<ExternVal> $externVals
+     */
+    public function allocPreInitModule(
+        Module $module,
+        array $externVals,
+    ): ModuleInst {
+        $m = new ModuleInst($module->types, [], [], [], [], [], [], []);
+
+        foreach ($externVals as $externVal) {
+            match ($externVal::class) {
+                ExternVals\Func::class => $m->funcAddrs[] = $externVal->addr,
+                ExternVals\Global_::class => $m->globalAddrs[] = $externVal->addr,
+                default => null,
+            };
+        }
+        foreach ($module->funcs as $func) {
+            $m->funcAddrs[] = $this->allocFunc($func, $m);
+        }
+
+        return $m;
+    }
+
+    /**
+     * @param list<ExternVal> $externVals
+     * @param list<int|float|Ref> $vals
+     * @param list<list<Ref>> $refsList
+     * @param list<int> $preAllocatedFuncs
+     */
+    public function allocModule(
+        Module $module,
+        array $externVals,
+        array $vals,
+        array $refsList,
+        array $preAllocatedFuncs,
+    ): ModuleInst {
+        $m = new ModuleInst($module->types, [], [], [], [], [], [], []);
+
+        foreach ($externVals as $externVal) {
+            match ($externVal::class) {
+                ExternVals\Func::class => null, // handled below.
+                ExternVals\Table::class => $m->tableAddrs[] = $externVal->addr,
+                ExternVals\Mem::class => $m->memAddrs[] = $externVal->addr,
+                ExternVals\Global_::class => $m->globalAddrs[] = $externVal->addr,
+                default => throw new RuntimeException("unreachable"),
+            };
+        }
+
+        foreach ($preAllocatedFuncs as $funcAddr) {
+            $m->funcAddrs[] = $funcAddr;
+            $funcInst = $this->store->funcs[$funcAddr];
+            if ($funcInst instanceof FuncInsts\Wasm) {
+                // @phpstan-ignore-next-line
+                $this->store->funcs[$funcAddr] = FuncInst::Wasm(
+                    $funcInst->type,
+                    $m,
+                    $funcInst->code,
+                );
+            }
+        }
+        foreach ($module->tables as $table) {
+            $m->tableAddrs[] = $this->allocTable($table->type, Ref::RefNull($table->type->refType));
+        }
+        foreach ($module->mems as $mem) {
+            $m->memAddrs[] = $this->allocMem($mem->type);
+        }
+        foreach ($module->datas as $data) {
+            $m->dataAddrs[] = $this->allocData($data->init);
+        }
+
+        foreach ($module->globals as $i => $global) {
+            $m->globalAddrs[] = $this->allocGlobal($global->type, $vals[$i]);
+        }
+        foreach ($module->elems as $i => $elem) {
+            $m->elemAddrs[] = $this->allocElem($elem->type, $refsList[$i]);
+        }
+
+        foreach ($module->exports as $export) {
+            $value = match ($export->desc::class) {
+                ExportDescs\Func::class => ExternVal::Func($m->funcAddrs[$export->desc->func]),
+                ExportDescs\Table::class => ExternVal::Table($m->tableAddrs[$export->desc->table]),
+                ExportDescs\Mem::class => ExternVal::Mem($m->memAddrs[$export->desc->mem]),
+                ExportDescs\Global_::class => ExternVal::Global_($m->globalAddrs[$export->desc->global]),
+                default => throw new RuntimeException("unreachable"),
+            };
+            $m->exports[] = new ExportInst($export->name, $value);
+        }
+
+        return $m;
+    }
+
+    private function allocFunc(Func $func, ModuleInst $moduleInst): int
+    {
+        $funcType = $moduleInst->types[$func->type];
+        $funcInst = FuncInst::Wasm($funcType, $moduleInst, $func);
+        $this->store->funcs[] = $funcInst;
+        return count($this->store->funcs) - 1;
+    }
+
+    private function allocTable(TableType $tableType, Ref $ref): int
+    {
+        $minSize = $tableType->limits->min;
+        $elem = array_fill(0, $minSize, $ref);
+        $tableInst = new TableInst($tableType, $elem);
+        $this->store->tables[] = $tableInst;
+        return count($this->store->tables) - 1;
+    }
+
+    private function allocMem(MemType $memType): int
+    {
+        $memInst = new MemInst($memType);
+        $this->store->mems[] = $memInst;
+        return count($this->store->mems) - 1;
+    }
+
+    private function allocGlobal(GlobalType $globalType, int|float|Ref $val): int
+    {
+        $globalInst = new GlobalInst($globalType, $val);
+        $this->store->globals[] = $globalInst;
+        return count($this->store->globals) - 1;
+    }
+
+    /**
+     * @param list<Ref> $elem
+     */
+    private function allocElem(RefType $refType, array $elem): int
+    {
+        $elemInst = new ElemInst($refType, $elem);
+        $this->store->elems[] = $elemInst;
+        return count($this->store->elems) - 1;
+    }
+
+    /**
+     * @param list<Byte> $data
+     */
+    private function allocData(array $data): int
+    {
+        $dataInst = new DataInst($data);
+        $this->store->datas[] = $dataInst;
+        return count($this->store->datas) - 1;
+    }
+}
diff --git a/src/WebAssembly/Execution/DataInst.php b/src/WebAssembly/Execution/DataInst.php
new file mode 100644
index 0000000..f6918c6
--- /dev/null
+++ b/src/WebAssembly/Execution/DataInst.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+final readonly class DataInst
+{
+    /**
+     * @param list<Byte> $data
+     */
+    public function __construct(
+        public array $data,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/ElemInst.php b/src/WebAssembly/Execution/ElemInst.php
new file mode 100644
index 0000000..422cd62
--- /dev/null
+++ b/src/WebAssembly/Execution/ElemInst.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\RefType;
+
+final readonly class ElemInst
+{
+    /**
+     * @param list<Ref> $elem
+     */
+    public function __construct(
+        public RefType $type,
+        public array $elem,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/ExportInst.php b/src/WebAssembly/Execution/ExportInst.php
new file mode 100644
index 0000000..7fe04cd
--- /dev/null
+++ b/src/WebAssembly/Execution/ExportInst.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+final readonly class ExportInst
+{
+    /**
+     * @param Name $name
+     */
+    public function __construct(
+        public string $name,
+        public ExternVal $value,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/Extern.php b/src/WebAssembly/Execution/Extern.php
new file mode 100644
index 0000000..dacfad1
--- /dev/null
+++ b/src/WebAssembly/Execution/Extern.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+abstract readonly class Extern
+{
+    final public static function Func(FuncInst $func): Externs\Func
+    {
+        return new Externs\Func($func);
+    }
+
+    final public static function Table(TableInst $table): Externs\Table
+    {
+        return new Externs\Table($table);
+    }
+
+    final public static function Mem(MemInst $mem): Externs\Mem
+    {
+        return new Externs\Mem($mem);
+    }
+
+    final public static function Global_(GlobalInst $global): Externs\Global_
+    {
+        return new Externs\Global_($global);
+    }
+}
diff --git a/src/WebAssembly/Execution/ExternVal.php b/src/WebAssembly/Execution/ExternVal.php
new file mode 100644
index 0000000..116ce53
--- /dev/null
+++ b/src/WebAssembly/Execution/ExternVal.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+abstract readonly class ExternVal
+{
+    final public static function Func(int $addr): ExternVals\Func
+    {
+        return new ExternVals\Func($addr);
+    }
+
+    final public static function Table(int $addr): ExternVals\Table
+    {
+        return new ExternVals\Table($addr);
+    }
+
+    final public static function Mem(int $addr): ExternVals\Mem
+    {
+        return new ExternVals\Mem($addr);
+    }
+
+    final public static function Global_(int $addr): ExternVals\Global_
+    {
+        return new ExternVals\Global_($addr);
+    }
+}
diff --git a/src/WebAssembly/Execution/ExternVals/Func.php b/src/WebAssembly/Execution/ExternVals/Func.php
new file mode 100644
index 0000000..cc3c82a
--- /dev/null
+++ b/src/WebAssembly/Execution/ExternVals/Func.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution\ExternVals;
+
+use Nsfisis\Waddiwasi\WebAssembly\Execution\ExternVal;
+
+final readonly class Func extends ExternVal
+{
+    protected function __construct(
+        public int $addr,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/ExternVals/Global_.php b/src/WebAssembly/Execution/ExternVals/Global_.php
new file mode 100644
index 0000000..cc28f26
--- /dev/null
+++ b/src/WebAssembly/Execution/ExternVals/Global_.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution\ExternVals;
+
+use Nsfisis\Waddiwasi\WebAssembly\Execution\ExternVal;
+
+final readonly class Global_ extends ExternVal
+{
+    protected function __construct(
+        public int $addr,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/ExternVals/Mem.php b/src/WebAssembly/Execution/ExternVals/Mem.php
new file mode 100644
index 0000000..1b76d3f
--- /dev/null
+++ b/src/WebAssembly/Execution/ExternVals/Mem.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution\ExternVals;
+
+use Nsfisis\Waddiwasi\WebAssembly\Execution\ExternVal;
+
+final readonly class Mem extends ExternVal
+{
+    protected function __construct(
+        public int $addr,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/ExternVals/Table.php b/src/WebAssembly/Execution/ExternVals/Table.php
new file mode 100644
index 0000000..787adb9
--- /dev/null
+++ b/src/WebAssembly/Execution/ExternVals/Table.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution\ExternVals;
+
+use Nsfisis\Waddiwasi\WebAssembly\Execution\ExternVal;
+
+final readonly class Table extends ExternVal
+{
+    protected function __construct(
+        public int $addr,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/Externs/Func.php b/src/WebAssembly/Execution/Externs/Func.php
new file mode 100644
index 0000000..3bfc116
--- /dev/null
+++ b/src/WebAssembly/Execution/Externs/Func.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution\Externs;
+
+use Nsfisis\Waddiwasi\WebAssembly\Execution\Extern;
+use Nsfisis\Waddiwasi\WebAssembly\Execution\FuncInst;
+
+final readonly class Func extends Extern
+{
+    protected function __construct(
+        public FuncInst $func,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/Externs/Global_.php b/src/WebAssembly/Execution/Externs/Global_.php
new file mode 100644
index 0000000..562e934
--- /dev/null
+++ b/src/WebAssembly/Execution/Externs/Global_.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution\Externs;
+
+use Nsfisis\Waddiwasi\WebAssembly\Execution\Extern;
+use Nsfisis\Waddiwasi\WebAssembly\Execution\GlobalInst;
+
+final readonly class Global_ extends Extern
+{
+    protected function __construct(
+        public GlobalInst $global,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/Externs/Mem.php b/src/WebAssembly/Execution/Externs/Mem.php
new file mode 100644
index 0000000..8924e00
--- /dev/null
+++ b/src/WebAssembly/Execution/Externs/Mem.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution\Externs;
+
+use Nsfisis\Waddiwasi\WebAssembly\Execution\Extern;
+use Nsfisis\Waddiwasi\WebAssembly\Execution\MemInst;
+
+final readonly class Mem extends Extern
+{
+    protected function __construct(
+        public MemInst $mem,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/Externs/Table.php b/src/WebAssembly/Execution/Externs/Table.php
new file mode 100644
index 0000000..65a833f
--- /dev/null
+++ b/src/WebAssembly/Execution/Externs/Table.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution\Externs;
+
+use Nsfisis\Waddiwasi\WebAssembly\Execution\Extern;
+use Nsfisis\Waddiwasi\WebAssembly\Execution\TableInst;
+
+final readonly class Table extends Extern
+{
+    protected function __construct(
+        public TableInst $table,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/Frame.php b/src/WebAssembly/Execution/Frame.php
new file mode 100644
index 0000000..331b43a
--- /dev/null
+++ b/src/WebAssembly/Execution/Frame.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+final class Frame
+{
+    /**
+     * @param int<0, max> $arity
+     * @param list<int|float|Ref> $locals
+     */
+    public function __construct(
+        public readonly int $arity,
+        public array $locals,
+        public readonly ModuleInst $module,
+        public string $debugName,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/FuncInst.php b/src/WebAssembly/Execution/FuncInst.php
new file mode 100644
index 0000000..dda32cf
--- /dev/null
+++ b/src/WebAssembly/Execution/FuncInst.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Func;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\FuncType;
+
+abstract readonly class FuncInst
+{
+    final public static function Wasm(FuncType $type, ModuleInst $module, Func $code): FuncInsts\Wasm
+    {
+        return new FuncInsts\Wasm($type, $module, $code);
+    }
+
+    final public static function Host(FuncType $type, callable $callback): FuncInsts\Host
+    {
+        return new FuncInsts\Host($type, $callback);
+    }
+}
diff --git a/src/WebAssembly/Execution/FuncInsts/Host.php b/src/WebAssembly/Execution/FuncInsts/Host.php
new file mode 100644
index 0000000..6a66325
--- /dev/null
+++ b/src/WebAssembly/Execution/FuncInsts/Host.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution\FuncInsts;
+
+use Nsfisis\Waddiwasi\WebAssembly\Execution\FuncInst;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\FuncType;
+
+final readonly class Host extends FuncInst
+{
+    /**
+     * @param callable $callback
+     */
+    public function __construct(
+        public FuncType $type,
+        public mixed $callback,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/FuncInsts/Wasm.php b/src/WebAssembly/Execution/FuncInsts/Wasm.php
new file mode 100644
index 0000000..d0780ab
--- /dev/null
+++ b/src/WebAssembly/Execution/FuncInsts/Wasm.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution\FuncInsts;
+
+use Nsfisis\Waddiwasi\WebAssembly\Execution\FuncInst;
+use Nsfisis\Waddiwasi\WebAssembly\Execution\ModuleInst;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Func;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\FuncType;
+
+final readonly class Wasm extends FuncInst
+{
+    public function __construct(
+        public FuncType $type,
+        public ModuleInst $module,
+        public Func $code,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/GlobalInst.php b/src/WebAssembly/Execution/GlobalInst.php
new file mode 100644
index 0000000..75f764f
--- /dev/null
+++ b/src/WebAssembly/Execution/GlobalInst.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\GlobalType;
+
+final class GlobalInst
+{
+    public function __construct(
+        public readonly GlobalType $type,
+        public int|float|Ref $value,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/Label.php b/src/WebAssembly/Execution/Label.php
new file mode 100644
index 0000000..85e90a7
--- /dev/null
+++ b/src/WebAssembly/Execution/Label.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+final readonly class Label
+{
+    /**
+     * @param int<0, max> $arity
+     */
+    public function __construct(
+        public int $arity,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/MemInst.php b/src/WebAssembly/Execution/MemInst.php
new file mode 100644
index 0000000..802f334
--- /dev/null
+++ b/src/WebAssembly/Execution/MemInst.php
@@ -0,0 +1,662 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+use FFI;
+use FFI\CData;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\Limits;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\MemType;
+use function assert;
+use function count;
+
+final class MemInst
+{
+    private const PAGE_SIZE = 64 * 1024;
+
+    private const MAX_PAGES = 0x10000;
+
+    private CData $dataU8;
+    private CData $dataS8;
+
+    private CData $dataU16_0;
+    private CData $dataU16_1;
+    private CData $dataS16_0;
+    private CData $dataS16_1;
+
+    private CData $dataU32_0;
+    private CData $dataU32_1;
+    private CData $dataU32_2;
+    private CData $dataU32_3;
+    private CData $dataS32_0;
+    private CData $dataS32_1;
+    private CData $dataS32_2;
+    private CData $dataS32_3;
+
+    private CData $dataS64_0;
+    private CData $dataS64_1;
+    private CData $dataS64_2;
+    private CData $dataS64_3;
+    private CData $dataS64_4;
+    private CData $dataS64_5;
+    private CData $dataS64_6;
+    private CData $dataS64_7;
+
+    private CData $dataF32_0;
+    private CData $dataF32_1;
+    private CData $dataF32_2;
+    private CData $dataF32_3;
+
+    private CData $dataF64_0;
+    private CData $dataF64_1;
+    private CData $dataF64_2;
+    private CData $dataF64_3;
+    private CData $dataF64_4;
+    private CData $dataF64_5;
+    private CData $dataF64_6;
+    private CData $dataF64_7;
+
+    private int $dataSize;
+
+    private readonly FFI $ffi;
+
+    public function __construct(
+        public MemType $type,
+    ) {
+        $this->ffi = FFI::cdef();
+        $this->initInternalMemory($type->limits->min);
+    }
+
+    public function size(): int
+    {
+        return $this->dataSize;
+    }
+
+    public function nPages(): int
+    {
+        return $this->size() / self::PAGE_SIZE;
+    }
+
+    /**
+     * @return int
+     *   Returns the original size of the memory in pages or -1 if failed.
+     */
+    public function grow(int $n): int
+    {
+        $sz = $this->nPages();
+        $len = $sz + $n;
+        if (self::MAX_PAGES < $len) {
+            return -1;
+        }
+
+        $limits = $this->type->limits;
+        $limits_ = new Limits($len, $limits->max);
+        if (!$limits_->isValid()) {
+            return -1;
+        }
+
+        $originalSize = $this->size();
+        // @phpstan-ignore-next-line
+        $originalData = $this->ffi->new("uint8_t[$originalSize+8]");
+        assert($originalData !== null);
+        FFI::memcpy($originalData, $this->dataU8, $originalSize);
+
+        $this->initInternalMemory($len);
+
+        FFI::memcpy($this->dataU8, $originalData, $originalSize);
+
+        return $sz;
+    }
+
+    private function initInternalMemory(int $n): void
+    {
+        $this->dataSize = $n * self::PAGE_SIZE;
+
+        // @phpstan-ignore-next-line
+        $this->dataU8 = $this->ffi->new("uint8_t[$this->dataSize+8]");
+        // @phpstan-ignore-next-line
+        $this->dataS8 = $this->ffi->cast("int8_t[$this->dataSize]", $this->dataU8);
+
+        // @phpstan-ignore-next-line
+        $castInt = fn ($n, $signed, $offset) => $this->ffi->cast(
+            sprintf("%sint%d_t[$this->dataSize/%d]", $signed ? "" : "u", $n, $n / 8),
+            // @phpstan-ignore-next-line
+            $this->ffi->cast("uint8_t[$this->dataSize+8]", $this->dataU8 + $offset),
+        );
+
+        // @phpstan-ignore-next-line
+        $castFloat = fn ($n, $offset) => $this->ffi->cast(
+            sprintf("%s[$this->dataSize/%d]", $n === 32 ? "float" : "double", $n / 8),
+            // @phpstan-ignore-next-line
+            $this->ffi->cast("uint8_t[$this->dataSize+8]", $this->dataU8 + $offset),
+        );
+
+        // @phpstan-ignore-next-line
+        $this->dataU16_0 = $castInt(16, false, 0);
+        // @phpstan-ignore-next-line
+        $this->dataU16_1 = $castInt(16, false, 1);
+        // @phpstan-ignore-next-line
+        $this->dataS16_0 = $castInt(16, true, 0);
+        // @phpstan-ignore-next-line
+        $this->dataS16_1 = $castInt(16, true, 1);
+
+        // @phpstan-ignore-next-line
+        $this->dataU32_0 = $castInt(32, false, 0);
+        // @phpstan-ignore-next-line
+        $this->dataU32_1 = $castInt(32, false, 1);
+        // @phpstan-ignore-next-line
+        $this->dataU32_2 = $castInt(32, false, 2);
+        // @phpstan-ignore-next-line
+        $this->dataU32_3 = $castInt(32, false, 3);
+        // @phpstan-ignore-next-line
+        $this->dataS32_0 = $castInt(32, true, 0);
+        // @phpstan-ignore-next-line
+        $this->dataS32_1 = $castInt(32, true, 1);
+        // @phpstan-ignore-next-line
+        $this->dataS32_2 = $castInt(32, true, 2);
+        // @phpstan-ignore-next-line
+        $this->dataS32_3 = $castInt(32, true, 3);
+
+        // @phpstan-ignore-next-line
+        $this->dataS64_0 = $castInt(64, true, 0);
+        // @phpstan-ignore-next-line
+        $this->dataS64_1 = $castInt(64, true, 1);
+        // @phpstan-ignore-next-line
+        $this->dataS64_2 = $castInt(64, true, 2);
+        // @phpstan-ignore-next-line
+        $this->dataS64_3 = $castInt(64, true, 3);
+        // @phpstan-ignore-next-line
+        $this->dataS64_4 = $castInt(64, true, 4);
+        // @phpstan-ignore-next-line
+        $this->dataS64_5 = $castInt(64, true, 5);
+        // @phpstan-ignore-next-line
+        $this->dataS64_6 = $castInt(64, true, 6);
+        // @phpstan-ignore-next-line
+        $this->dataS64_7 = $castInt(64, true, 7);
+
+        // @phpstan-ignore-next-line
+        $this->dataF32_0 = $castFloat(32, 0);
+        // @phpstan-ignore-next-line
+        $this->dataF32_1 = $castFloat(32, 1);
+        // @phpstan-ignore-next-line
+        $this->dataF32_2 = $castFloat(32, 2);
+        // @phpstan-ignore-next-line
+        $this->dataF32_3 = $castFloat(32, 3);
+
+        // @phpstan-ignore-next-line
+        $this->dataF64_0 = $castFloat(64, 0);
+        // @phpstan-ignore-next-line
+        $this->dataF64_1 = $castFloat(64, 1);
+        // @phpstan-ignore-next-line
+        $this->dataF64_2 = $castFloat(64, 2);
+        // @phpstan-ignore-next-line
+        $this->dataF64_3 = $castFloat(64, 3);
+        // @phpstan-ignore-next-line
+        $this->dataF64_4 = $castFloat(64, 4);
+        // @phpstan-ignore-next-line
+        $this->dataF64_5 = $castFloat(64, 5);
+        // @phpstan-ignore-next-line
+        $this->dataF64_6 = $castFloat(64, 6);
+        // @phpstan-ignore-next-line
+        $this->dataF64_7 = $castFloat(64, 7);
+
+        // @phpstan-ignore-next-line
+        FFI::memset($this->dataU8, 0, $this->dataSize);
+    }
+
+    /**
+     * @param list<int> $data
+     */
+    public function copyData(array $data, int $src, int $dst, int $len): void
+    {
+        assert(0 <= $len);
+        assert(0 <= $src);
+        assert(0 <= $dst);
+        assert($src + $len <= count($data));
+        assert($dst + $len <= $this->size());
+        for ($i = 0; $i < $len; $i++) {
+            $this->storeByte($dst + $i, $data[$src + $i]);
+        }
+    }
+
+    public function memcpy(int $dst, int $src, int $len): void
+    {
+        assert(0 <= $len);
+        assert(0 <= $src);
+        assert(0 <= $dst);
+        assert($src + $len <= $this->size());
+        assert($dst + $len <= $this->size());
+        if ($src === $dst || $len === 0) {
+            return;
+        }
+        for ($i = 0; $i < $len; $i++) {
+            $s = ($dst < $src) ? ($src + $i) : ($src + $len - 1 - $i);
+            $d = ($dst < $src) ? ($dst + $i) : ($dst + $len - 1 - $i);
+            $x = $this->loadByte($s);
+            assert($x !== null);
+            $this->storeByte($d, $x);
+        }
+    }
+
+    public function memset(int $dst, int $c, int $len): void
+    {
+        assert(0 <= $len);
+        assert(0 <= $dst);
+        assert($dst + $len <= $this->size());
+        for ($i = 0; $i < $len; $i++) {
+            $this->storeI32_s8($dst + $i, $c);
+        }
+    }
+
+    /**
+     * @return ?S32
+     */
+    public function loadI32_s8(int $ptr): ?int
+    {
+        if ($this->size() < $ptr + 1) {
+            return null;
+        }
+        // @phpstan-ignore-next-line
+        $c = $this->dataS8[$ptr];
+        assert(-0x80 <= $c && $c <= 0x7F, "$c");
+        return $c;
+    }
+
+    /**
+     * @return ?S32
+     */
+    public function loadI32_u8(int $ptr): ?int
+    {
+        if ($this->size() < $ptr + 1) {
+            return null;
+        }
+        // @phpstan-ignore-next-line
+        $c = $this->dataU8[$ptr];
+        assert(0 <= $c && $c <= 0xFF, "$c");
+        return $c;
+    }
+
+    /**
+     * @return ?S32
+     */
+    public function loadI32_s16(int $ptr): ?int
+    {
+        if ($this->size() < $ptr + 2) {
+            return null;
+        }
+        // @phpstan-ignore-next-line
+        $c = $this->dataS16($ptr)[$ptr >> 1];
+        assert(-0x8000 <= $c && $c <= 0x7FFF, "$c");
+        return $c;
+    }
+
+    /**
+     * @return ?S32
+     */
+    public function loadI32_u16(int $ptr): ?int
+    {
+        if ($this->size() < $ptr + 2) {
+            return null;
+        }
+        // @phpstan-ignore-next-line
+        $c = $this->dataU16($ptr)[$ptr >> 1];
+        assert(0 <= $c && $c <= 0xFFFF, "$c");
+        return $c;
+    }
+
+    /**
+     * @return ?S32
+     */
+    public function loadI32_s32(int $ptr): ?int
+    {
+        if ($this->size() < $ptr + 4) {
+            return null;
+        }
+        // @phpstan-ignore-next-line
+        $c = $this->dataS32($ptr)[$ptr >> 2];
+        assert(-0x80000000 <= $c && $c <= 0x7FFFFFFF, "$c");
+        return $c;
+    }
+
+    /**
+     * @return ?S64
+     */
+    public function loadI64_s8(int $ptr): ?int
+    {
+        if ($this->size() < $ptr + 1) {
+            return null;
+        }
+        // @phpstan-ignore-next-line
+        $c = $this->dataS8[$ptr];
+        assert(-0x80 <= $c && $c <= 0x7F, "$c");
+        return $c;
+    }
+
+    /**
+     * @return ?S64
+     */
+    public function loadI64_u8(int $ptr): ?int
+    {
+        if ($this->size() < $ptr + 1) {
+            return null;
+        }
+        // @phpstan-ignore-next-line
+        $c = $this->dataU8[$ptr];
+        assert(0 <= $c && $c <= 0xFF, "$c");
+        return $c;
+    }
+
+    /**
+     * @return ?S64
+     */
+    public function loadI64_s16(int $ptr): ?int
+    {
+        if ($this->size() < $ptr + 2) {
+            return null;
+        }
+        // @phpstan-ignore-next-line
+        $c = $this->dataS16($ptr)[$ptr >> 1];
+        assert(-0x8000 <= $c && $c <= 0x7FFF, "$c");
+        return $c;
+    }
+
+    /**
+     * @return ?S64
+     */
+    public function loadI64_u16(int $ptr): ?int
+    {
+        if ($this->size() < $ptr + 2) {
+            return null;
+        }
+        // @phpstan-ignore-next-line
+        $c = $this->dataU16($ptr)[$ptr >> 1];
+        assert(0 <= $c && $c <= 0xFFFF, "$c");
+        return $c;
+    }
+
+    /**
+     * @return ?S64
+     */
+    public function loadI64_s32(int $ptr): ?int
+    {
+        if ($this->size() < $ptr + 4) {
+            return null;
+        }
+        // @phpstan-ignore-next-line
+        $c = $this->dataS32($ptr)[$ptr >> 2];
+        assert(-0x80000000 <= $c && $c <= 0x7FFFFFFF, "$c");
+        return $c;
+    }
+
+    /**
+     * @return ?S64
+     */
+    public function loadI64_u32(int $ptr): ?int
+    {
+        if ($this->size() < $ptr + 4) {
+            return null;
+        }
+        // @phpstan-ignore-next-line
+        $c = $this->dataU32($ptr)[$ptr >> 2];
+        assert(0 <= $c && $c <= 0xFFFFFFFF, "$c");
+        return $c;
+    }
+
+    /**
+     * @return ?S64
+     */
+    public function loadI64_s64(int $ptr): ?int
+    {
+        if ($this->size() < $ptr + 8) {
+            return null;
+        }
+        // @phpstan-ignore-next-line
+        $c = $this->dataS64($ptr)[$ptr >> 3];
+        assert(-0x8000000000000000 <= $c && $c <= 0x7FFFFFFFFFFFFFFF, "$c");
+        return $c;
+    }
+
+    /**
+     * @return ?F32
+     */
+    public function loadF32(int $ptr): ?float
+    {
+        if ($this->size() < $ptr + 4) {
+            return null;
+        }
+        // @phpstan-ignore-next-line
+        return $this->dataF32($ptr)[$ptr >> 2];
+    }
+
+    /**
+     * @return ?F64
+     */
+    public function loadF64(int $ptr): ?float
+    {
+        if ($this->size() < $ptr + 8) {
+            return null;
+        }
+        // @phpstan-ignore-next-line
+        return $this->dataF64($ptr)[$ptr >> 3];
+    }
+
+    /**
+     * @return ?int
+     */
+    public function loadByte(int $ptr): ?int
+    {
+        if ($this->size() < $ptr + 1) {
+            return null;
+        }
+        // @phpstan-ignore-next-line
+        return $this->dataU8[$ptr];
+    }
+
+    /**
+     * @return bool
+     */
+    public function storeByte(int $ptr, int $c): bool
+    {
+        if ($this->size() < $ptr + 1) {
+            return false;
+        }
+        // @phpstan-ignore-next-line
+        $this->dataU8[$ptr] = $c;
+        return true;
+    }
+
+    /**
+     * @param S32 $c
+     * @return bool
+     */
+    public function storeI32_s8(int $ptr, int $c): bool
+    {
+        if ($this->size() < $ptr + 1) {
+            return false;
+        }
+        // @phpstan-ignore-next-line
+        $this->dataS8[$ptr] = $c;
+        return true;
+    }
+
+    /**
+     * @param S32 $c
+     * @return bool
+     */
+    public function storeI32_s16(int $ptr, int $c): bool
+    {
+        if ($this->size() < $ptr + 2) {
+            return false;
+        }
+        // @phpstan-ignore-next-line
+        $this->dataS16($ptr)[$ptr >> 1] = $c;
+        return true;
+    }
+
+    /**
+     * @param S32 $c
+     * @return bool
+     */
+    public function storeI32_s32(int $ptr, int $c): bool
+    {
+        if ($this->size() < $ptr + 4) {
+            return false;
+        }
+        // @phpstan-ignore-next-line
+        $this->dataS32($ptr)[$ptr >> 2] = $c;
+        return true;
+    }
+
+    /**
+     * @param S64 $c
+     * @return bool
+     */
+    public function storeI64_s8(int $ptr, int $c): bool
+    {
+        if ($this->size() < $ptr + 1) {
+            return false;
+        }
+        // @phpstan-ignore-next-line
+        $this->dataS8[$ptr] = $c;
+        return true;
+    }
+
+    /**
+     * @param S64 $c
+     * @return bool
+     */
+    public function storeI64_s16(int $ptr, int $c): bool
+    {
+        if ($this->size() < $ptr + 2) {
+            return false;
+        }
+        // @phpstan-ignore-next-line
+        $this->dataS16($ptr)[$ptr >> 1] = $c;
+        return true;
+    }
+
+    /**
+     * @param S64 $c
+     * @return bool
+     */
+    public function storeI64_s32(int $ptr, int $c): bool
+    {
+        if ($this->size() < $ptr + 4) {
+            return false;
+        }
+        // @phpstan-ignore-next-line
+        $this->dataS32($ptr)[$ptr >> 2] = $c;
+        return true;
+    }
+
+    /**
+     * @param S64 $c
+     * @return bool
+     */
+    public function storeI64_s64(int $ptr, int $c): bool
+    {
+        if ($this->size() < $ptr + 8) {
+            return false;
+        }
+        // @phpstan-ignore-next-line
+        $this->dataS64($ptr)[$ptr >> 3] = $c;
+        return true;
+    }
+
+    /**
+     * @param F32 $c
+     * @return bool
+     */
+    public function storeF32(int $ptr, float $c): bool
+    {
+        if ($this->size() < $ptr + 4) {
+            return false;
+        }
+        // @phpstan-ignore-next-line
+        $this->dataF32($ptr)[$ptr >> 2] = $c;
+        return true;
+    }
+
+    /**
+     * @param F64 $c
+     * @return bool
+     */
+    public function storeF64(int $ptr, float $c): bool
+    {
+        if ($this->size() < $ptr + 8) {
+            return false;
+        }
+        // @phpstan-ignore-next-line
+        $this->dataF64($ptr)[$ptr >> 3] = $c;
+        return true;
+    }
+
+    private function dataU16(int $ptr): CData
+    {
+        return ($ptr & 1) !== 0 ? $this->dataU16_1 : $this->dataU16_0;
+    }
+
+    private function dataS16(int $ptr): CData
+    {
+        return ($ptr & 1) !== 0 ? $this->dataS16_1 : $this->dataS16_0;
+    }
+
+    private function dataU32(int $ptr): CData
+    {
+        return match ($ptr & 3) {
+            0 => $this->dataU32_0,
+            1 => $this->dataU32_1,
+            2 => $this->dataU32_2,
+            3 => $this->dataU32_3,
+        };
+    }
+
+    private function dataS32(int $ptr): CData
+    {
+        return match ($ptr & 3) {
+            0 => $this->dataS32_0,
+            1 => $this->dataS32_1,
+            2 => $this->dataS32_2,
+            3 => $this->dataS32_3,
+        };
+    }
+
+    private function dataS64(int $ptr): CData
+    {
+        return match ($ptr & 7) {
+            0 => $this->dataS64_0,
+            1 => $this->dataS64_1,
+            2 => $this->dataS64_2,
+            3 => $this->dataS64_3,
+            4 => $this->dataS64_4,
+            5 => $this->dataS64_5,
+            6 => $this->dataS64_6,
+            7 => $this->dataS64_7,
+        };
+    }
+
+    private function dataF32(int $ptr): CData
+    {
+        return match ($ptr & 3) {
+            0 => $this->dataF32_0,
+            1 => $this->dataF32_1,
+            2 => $this->dataF32_2,
+            3 => $this->dataF32_3,
+        };
+    }
+
+    private function dataF64(int $ptr): CData
+    {
+        return match ($ptr & 7) {
+            0 => $this->dataF64_0,
+            1 => $this->dataF64_1,
+            2 => $this->dataF64_2,
+            3 => $this->dataF64_3,
+            4 => $this->dataF64_4,
+            5 => $this->dataF64_5,
+            6 => $this->dataF64_6,
+            7 => $this->dataF64_7,
+        };
+    }
+}
diff --git a/src/WebAssembly/Execution/ModuleInst.php b/src/WebAssembly/Execution/ModuleInst.php
new file mode 100644
index 0000000..37bbcfd
--- /dev/null
+++ b/src/WebAssembly/Execution/ModuleInst.php
@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\FuncType;
+
+final class ModuleInst
+{
+    /**
+     * @param list<FuncType> $types
+     * @param list<int> $funcAddrs
+     * @param list<int> $tableAddrs
+     * @param list<int> $memAddrs
+     * @param list<int> $globalAddrs
+     * @param list<int> $elemAddrs
+     * @param list<int> $dataAddrs
+     * @param list<ExportInst> $exports
+     */
+    public function __construct(
+        public array $types,
+        public array $funcAddrs,
+        public array $tableAddrs,
+        public array $memAddrs,
+        public array $globalAddrs,
+        public array $elemAddrs,
+        public array $dataAddrs,
+        public array $exports,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/NumericOps.php b/src/WebAssembly/Execution/NumericOps.php
new file mode 100644
index 0000000..895b8c2
--- /dev/null
+++ b/src/WebAssembly/Execution/NumericOps.php
@@ -0,0 +1,193 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+use InvalidArgumentException;
+use function assert;
+use function bcadd;
+use function bccomp;
+use function bcmod;
+use function bcpow;
+use function bcsub;
+use function fdiv;
+use function is_nan;
+use function pack;
+use function unpack;
+
+final readonly class NumericOps
+{
+    private function __construct()
+    {
+    }
+
+    public static function reinterpretI32AsF32(int $x): float
+    {
+        return self::deserializeF32FromBytes(self::serializeI32ToBytes($x));
+    }
+
+    public static function reinterpretI64AsF32(int $x): float
+    {
+        return self::deserializeF32FromBytes(self::serializeI64ToBytes($x));
+    }
+
+    public static function reinterpretI32AsF64(int $x): float
+    {
+        return self::deserializeF64FromBytes(self::serializeI32ToBytes($x));
+    }
+
+    public static function reinterpretI64AsF64(int $x): float
+    {
+        return self::deserializeF64FromBytes(self::serializeI64ToBytes($x));
+    }
+
+    public static function reinterpretF32AsI32(float $x): int
+    {
+        return self::deserializeI32FromBytes(self::serializeF32ToBytes($x));
+    }
+
+    public static function reinterpretF64AsI32(float $x): int
+    {
+        return self::deserializeI32FromBytes(self::serializeF64ToBytes($x));
+    }
+
+    public static function reinterpretF32AsI64(float $x): int
+    {
+        return self::deserializeI64FromBytes(self::serializeF32ToBytes($x));
+    }
+
+    public static function reinterpretF64AsI64(float $x): int
+    {
+        return self::deserializeI64FromBytes(self::serializeF64ToBytes($x));
+    }
+
+    public static function truncateF64ToF32(float $x): float
+    {
+        return self::deserializeF32FromBytes(self::serializeF32ToBytes($x));
+    }
+
+    public static function serializeI32ToBytes(int $x): string
+    {
+        return pack('l', $x);
+    }
+
+    public static function deserializeI32FromBytes(string $s): int
+    {
+        $result = unpack('l', $s);
+        if ($result === false) {
+            throw new InvalidArgumentException("Failed to unpack i32: $s");
+        }
+        return $result[1];
+    }
+
+    public static function serializeI64ToBytes(int $x): string
+    {
+        return pack('q', $x);
+    }
+
+    public static function deserializeI64FromBytes(string $s): int
+    {
+        $result = unpack('q', $s);
+        if ($result === false) {
+            throw new InvalidArgumentException("Failed to unpack i64: $s");
+        }
+        return $result[1];
+    }
+
+    public static function serializeF32ToBytes(float $x): string
+    {
+        return pack('f', $x);
+    }
+
+    public static function deserializeF32FromBytes(string $s): float
+    {
+        $result = unpack('f', $s);
+        if ($result === false) {
+            throw new InvalidArgumentException("Failed to unpack f32: $s");
+        }
+        return $result[1];
+    }
+
+    public static function serializeF64ToBytes(float $x): string
+    {
+        return pack('d', $x);
+    }
+
+    public static function deserializeF64FromBytes(string $s): float
+    {
+        $result = unpack('d', $s);
+        if ($result === false) {
+            throw new InvalidArgumentException("Failed to unpack f64: $s");
+        }
+        return $result[1];
+    }
+
+    public static function convertS32ToU32(int $x): int
+    {
+        // assert(-0x80000000 <= $x && $x <= 0x7FFFFFFF, "convertS32ToU32: out of range $x");
+        if ($x < 0) {
+            $buf = pack('l', $x);
+            $result = unpack('L', $buf);
+            assert($result !== false);
+            assert(0x00000000 <= $result[1] && $result[1] <= 0xFFFFFFFF, "convertS32ToU32: out of range $result[1]");
+            return $result[1];
+        } else {
+            return $x;
+        }
+    }
+
+    public static function convertU32ToS32(int $x): int
+    {
+        assert(0x00000000 <= $x && $x <= 0xFFFFFFFF);
+        if (($x & 0x80000000) !== 0) {
+            $buf = pack('L', $x);
+            $result = unpack('l', $buf);
+            assert($result !== false);
+            assert(-0x80000000 <= $result[1] && $result[1] <= 0x7FFFFFFF, "convertU32ToS32: out of range $result[1]");
+            return $result[1];
+        } else {
+            return $x;
+        }
+    }
+
+    public static function convertS64ToBigUInt(int $x): string
+    {
+        if ($x < 0) {
+            return bcadd((string)$x, '18446744073709551616');
+        } else {
+            return (string)$x;
+        }
+    }
+
+    public static function bigIntToPhpInt(string $s): int
+    {
+        $result = bcmod($s, bcpow('2', '64'));
+        if ($result[0] === '-') {
+            // 2^63 <= -$result
+            if (bccomp(bcpow('2', '63'), bcsub('0', $result)) <= 0) {
+                $result = bcadd($result, bcpow('2', '64'));
+            }
+        } else {
+            // 2^63-1 < $result
+            if (bccomp(bcsub(bcpow('2', '63'), '1'), $result) < 0) {
+                $result = bcsub($result, bcpow('2', '64'));
+            }
+        }
+        return (int)$result;
+    }
+
+    public static function getFloatSign(float $p): int
+    {
+        if (is_nan($p)) {
+            $n = self::reinterpretF64AsI64($p);
+            // The MSB is the sign bit.
+            return (($n >> 63) & 1) === 1 ? -1 : 1;
+        } elseif ($p !== 0.0) {
+            return $p < 0.0 ? -1 : 1;
+        } else {
+            // Comparison with 0 does not work for -0.0.
+            return fdiv(1, $p) < 0.0 ? -1 : 1;
+        }
+    }
+}
diff --git a/src/WebAssembly/Execution/Ref.php b/src/WebAssembly/Execution/Ref.php
new file mode 100644
index 0000000..f7b6760
--- /dev/null
+++ b/src/WebAssembly/Execution/Ref.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\RefType;
+
+abstract readonly class Ref
+{
+    final public static function RefNull(RefType $type): Refs\RefNull
+    {
+        return new Refs\RefNull($type);
+    }
+
+    final public static function RefFunc(int $addr): Refs\RefFunc
+    {
+        return new Refs\RefFunc($addr);
+    }
+
+    final public static function RefExtern(int $addr): Refs\RefExtern
+    {
+        return new Refs\RefExtern($addr);
+    }
+}
diff --git a/src/WebAssembly/Execution/Refs/RefExtern.php b/src/WebAssembly/Execution/Refs/RefExtern.php
new file mode 100644
index 0000000..41f3acd
--- /dev/null
+++ b/src/WebAssembly/Execution/Refs/RefExtern.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution\Refs;
+
+use Nsfisis\Waddiwasi\WebAssembly\Execution\Ref;
+
+final readonly class RefExtern extends Ref
+{
+    public function __construct(
+        public int $addr,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/Refs/RefFunc.php b/src/WebAssembly/Execution/Refs/RefFunc.php
new file mode 100644
index 0000000..3eabf4b
--- /dev/null
+++ b/src/WebAssembly/Execution/Refs/RefFunc.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution\Refs;
+
+use Nsfisis\Waddiwasi\WebAssembly\Execution\Ref;
+
+final readonly class RefFunc extends Ref
+{
+    public function __construct(
+        public int $addr,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/Refs/RefNull.php b/src/WebAssembly/Execution/Refs/RefNull.php
new file mode 100644
index 0000000..438ed9e
--- /dev/null
+++ b/src/WebAssembly/Execution/Refs/RefNull.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution\Refs;
+
+use Nsfisis\Waddiwasi\WebAssembly\Execution\Ref;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\RefType;
+
+final readonly class RefNull extends Ref
+{
+    public function __construct(
+        public RefType $type,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/Result.php b/src/WebAssembly/Execution/Result.php
new file mode 100644
index 0000000..50e543c
--- /dev/null
+++ b/src/WebAssembly/Execution/Result.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+abstract readonly class Result
+{
+    /**
+     * @param list<int|float|Ref> $values
+     */
+    final public static function Values(array $values): Results\Values
+    {
+        return new Results\Values($values);
+    }
+
+    final public static function Trap(): Results\Trap
+    {
+        return new Results\Trap();
+    }
+}
diff --git a/src/WebAssembly/Execution/Results/Trap.php b/src/WebAssembly/Execution/Results/Trap.php
new file mode 100644
index 0000000..e0a9cfd
--- /dev/null
+++ b/src/WebAssembly/Execution/Results/Trap.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution\Results;
+
+use Nsfisis\Waddiwasi\WebAssembly\Execution\Result;
+
+final readonly class Trap extends Result
+{
+}
diff --git a/src/WebAssembly/Execution/Results/Values.php b/src/WebAssembly/Execution/Results/Values.php
new file mode 100644
index 0000000..9391a2c
--- /dev/null
+++ b/src/WebAssembly/Execution/Results/Values.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution\Results;
+
+use Nsfisis\Waddiwasi\WebAssembly\Execution\Ref;
+use Nsfisis\Waddiwasi\WebAssembly\Execution\Result;
+
+final readonly class Values extends Result
+{
+    /**
+     * @param list<int|float|Ref> $values
+     */
+    protected function __construct(
+        public array $values,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/Runtime.php b/src/WebAssembly/Execution/Runtime.php
new file mode 100644
index 0000000..dbefea2
--- /dev/null
+++ b/src/WebAssembly/Execution/Runtime.php
@@ -0,0 +1,2668 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control\BlockType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control\BlockTypes;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\DataModes;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ElemModes;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\Module;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\FuncType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\Limits;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\NumType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ResultType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\TableType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValTypes;
+use RuntimeException;
+use function abs;
+use function array_map;
+use function array_merge;
+use function array_reverse;
+use function assert;
+use function ceil;
+use function count;
+use function fdiv;
+use function floor;
+use function intdiv;
+use function is_array;
+use function is_infinite;
+use function is_int;
+use function is_nan;
+use function max;
+use function min;
+use function pack;
+use function round;
+use function sqrt;
+use function unpack;
+use const PHP_INT_MIN;
+
+final class Runtime
+{
+    /**
+     * @var array<string, array{int, int}>
+     */
+    private array $instrMetrics = [];
+
+    private function __construct(
+        public readonly Store $store,
+        public readonly Stack $stack,
+        public readonly ModuleInst $module,
+    ) {
+    }
+
+    /**
+     * @param array<string, array<string, Extern>> $imports
+     */
+    public static function instantiate(
+        Store $store,
+        Module $module,
+        array $imports,
+    ): self {
+        $externVals = [];
+        foreach ($module->imports as $import) {
+            $extern = $imports[$import->module][$import->name] ?? null;
+            if ($extern === null) {
+                throw new RuntimeException("instantiate: import not found: {$import->module}::{$import->name}");
+            }
+            $externVals[] = $store->register($extern);
+        }
+        return self::doInstantiate($store, $module, $externVals);
+    }
+
+    /**
+     * @param list<ExternVal> $externVals
+     */
+    private static function doInstantiate(
+        Store $store,
+        Module $module,
+        array $externVals,
+    ): self {
+        $allocator = new Allocator($store);
+
+        $moduleInstInit = $allocator->allocPreInitModule($module, $externVals);
+
+        $stack = new Stack();
+        $frameInit = new Frame(0, [], $moduleInstInit, 'preinit');
+        $stack->pushFrame($frameInit);
+
+        $runtimeInit = new self($store, $stack, $moduleInstInit);
+
+        $vals = [];
+        foreach ($module->globals as $global) {
+            $vals[] = $runtimeInit->evalInstrsForInit($global->init);
+            assert($stack->top() === $frameInit);
+        }
+
+        $refsList = [];
+        foreach ($module->elems as $elem) {
+            $refs = [];
+            foreach ($elem->init as $expr) {
+                $result = $runtimeInit->evalInstrsForInit($expr);
+                assert($result instanceof Ref);
+                $refs[] = $result;
+            }
+            $refsList[] = $refs;
+        }
+
+        assert($stack->top() === $frameInit);
+        $stack->popFrame();
+
+        $moduleInst = $allocator->allocModule(
+            $module,
+            $externVals,
+            $vals,
+            $refsList,
+            $moduleInstInit->funcAddrs,
+        );
+
+        $runtime = new self($store, $stack, $moduleInst);
+
+        $frame = new Frame(0, [], $moduleInst, 'init');
+        $stack->pushFrame($frame);
+
+        foreach ($module->elems as $i => $elem) {
+            if ($elem->mode instanceof ElemModes\Active) {
+                $n = count($elem->init);
+                $instrs = $elem->mode->offset;
+                $instrs[] = Instr::I32Const(0);
+                $instrs[] = Instr::I32Const($n);
+                $instrs[] = Instr::TableInit($elem->mode->table, $i);
+                $instrs[] = Instr::ElemDrop($i);
+                $runtime->execInstrsForInit($instrs);
+            } elseif ($elem->mode instanceof ElemModes\Declarative) {
+                $runtime->execInstrsForInit([Instr::ElemDrop($i)]);
+            }
+        }
+        foreach ($module->datas as $i => $data) {
+            if ($data->mode instanceof DataModes\Active) {
+                assert($data->mode->memory === 0);
+                $n = count($data->init);
+                $instrs = $data->mode->offset;
+                $instrs[] = Instr::I32Const(0);
+                $instrs[] = Instr::I32Const($n);
+                $instrs[] = Instr::MemoryInit($i);
+                $instrs[] = Instr::DataDrop($i);
+                $runtime->execInstrsForInit($instrs);
+            }
+        }
+
+        if ($module->start !== null) {
+            $runtime->execInstrsForInit([Instr::Call($module->start->func)]);
+        }
+
+        assert($stack->top() === $frame);
+        $stack->popFrame();
+
+        return new self($store, $stack, $moduleInst);
+    }
+
+    public function getExport(string $name): ?ExternVal
+    {
+        foreach ($this->module->exports as $export) {
+            if ($name === $export->name) {
+                return $export->value;
+            }
+        }
+        return null;
+    }
+
+    public function getExportedTable(string $name): ?TableInst
+    {
+        $export = $this->getExport($name);
+        if ($export instanceof ExternVals\Table) {
+            return $this->store->tables[$export->addr];
+        }
+        return null;
+    }
+
+    public function getExportedMemory(string $name): ?MemInst
+    {
+        $export = $this->getExport($name);
+        if ($export instanceof ExternVals\Mem) {
+            return $this->store->mems[$export->addr];
+        }
+        return null;
+    }
+
+    /**
+     * @return array<string, array{int, int}>
+     */
+    public function getInstrMetrics(): array
+    {
+        asort($this->instrMetrics);
+        return $this->instrMetrics;
+    }
+
+    /**
+     * @param list<int|float|Ref> $vals
+     * @return list<int|float|Ref>
+     */
+    public function invoke(string $name, array $vals): array
+    {
+        try {
+            $export = $this->getExport($name);
+            assert($export instanceof ExternVals\Func);
+            $funcAddr = $export->addr;
+
+            $funcInst = $this->store->funcs[$funcAddr];
+            assert($funcInst instanceof FuncInsts\Wasm);
+            $paramTypes = $funcInst->type->params->types;
+            $resultTypes = $funcInst->type->results->types;
+            if (count($paramTypes) !== count($vals)) {
+                throw new RuntimeException("invoke($name) invalid function arity: expected " . count($paramTypes) . ", got " . count($vals));
+            }
+            $f = new Frame(0, [], new ModuleInst([], [], [], [], [], [], [], []), "export: $name");
+            $this->stack->pushFrame($f);
+            foreach ($vals as $val) {
+                $this->stack->pushValue($val);
+            }
+            $this->doInvokeFunc($funcAddr);
+            $results = $this->stack->popNValues(count($resultTypes));
+            $this->stack->popFrame();
+            return array_reverse($results);
+        } catch (RuntimeException $e) {
+            // @todo more reliable way to clear the stack
+            $this->stack->clear();
+            throw $e;
+        }
+    }
+
+    public function invokeByFuncAddr(int $funcAddr): void
+    {
+        $this->doInvokeFunc($funcAddr);
+    }
+
+    private function doInvokeFunc(int $funcAddr): void
+    {
+        $fn = $this->store->funcs[$funcAddr];
+        if ($fn instanceof FuncInsts\Wasm) {
+            $this->doInvokeWasmFunc($fn, $funcAddr);
+        } elseif ($fn instanceof FuncInsts\Host) {
+            $this->doInvokeHostFunc($fn);
+        } else {
+            throw new RuntimeException("doInvokeFunc: unreachable");
+        }
+    }
+
+    private function doInvokeWasmFunc(FuncInsts\Wasm $fn, int $funcAddr): void
+    {
+        $paramTypes = $fn->type->params->types;
+        $n = count($paramTypes);
+        $resultTypes = $fn->type->results->types;
+        $m = count($resultTypes);
+        $ts = $fn->code->locals;
+        $vals = $this->stack->popNValues($n);
+        $f = new Frame(
+            $m,
+            array_merge(
+                array_reverse($vals),
+                array_map(fn ($local) => self::defaultValueFromValType($local->type), $ts),
+            ),
+            $fn->module,
+            "wasm: $funcAddr",
+        );
+        $this->activateFrame($f);
+        $l = new Label($m);
+        $this->execInstrs($fn->code->body, $l, null);
+        $this->deactivateFrame($m);
+    }
+
+    private function activateFrame(Frame $f): void
+    {
+        $this->stack->pushFrame($f);
+    }
+
+    private function deactivateFrame(int $arity): void
+    {
+        $vals = $this->stack->popNValues($arity);
+        $this->stack->popEntriesToCurrentFrame();
+        for ($i = $arity - 1; 0 <= $i; $i--) {
+            $this->stack->pushValue($vals[$i]);
+        }
+    }
+
+    private function activateLabel(Label $l): void
+    {
+        $this->stack->pushLabel($l);
+    }
+
+    private function deactivateLabel(?int $arity): void
+    {
+        if ($arity === null) {
+            $vals = $this->stack->popValuesToLabel();
+        } else {
+            $vals = $this->stack->popNValues($arity);
+            $this->stack->popValuesToLabel();
+        }
+        for ($i = count($vals) - 1; 0 <= $i; $i--) {
+            $this->stack->pushValue($vals[$i]);
+        }
+    }
+
+    private function doInvokeHostFunc(FuncInsts\Host $fn): void
+    {
+        $paramTypes = $fn->type->params->types;
+        $n = count($paramTypes);
+        $resultTypes = $fn->type->results->types;
+        $m = count($resultTypes);
+
+        $params = array_reverse($this->stack->popNValues($n));
+        $results = ($fn->callback)($this, ...$params);
+        if ($results === null) {
+            assert($m === 0);
+            return;
+        }
+        if (!is_array($results)) {
+            $results = [$results];
+        }
+        assert($m === count($results));
+        foreach ($results as $result) {
+            $this->stack->pushValue($result);
+        }
+    }
+
+    /**
+     * @param list<Instr> $instrs
+     * @param ?list<int|float|Ref> $params
+     */
+    private function execInstrs(
+        array $instrs,
+        Label $l,
+        ?array $params,
+    ): ?int {
+        $this->activateLabel($l);
+        if ($params !== null) {
+            foreach ($params as $param) {
+                $this->stack->pushValue($param);
+            }
+        }
+
+        foreach ($instrs as $i => $instr) {
+            $result = $this->execInstr($instr);
+            if ($result !== null) {
+                return $result;
+            }
+        }
+
+        $this->deactivateLabel(null);
+        return null;
+    }
+
+    /**
+     * @param list<Instr> $instrs
+     */
+    private function execInstrsForInit(array $instrs): void
+    {
+        foreach ($instrs as $i) {
+            $this->execInstr($i);
+        }
+    }
+
+    /**
+     * @param list<Instr> $instrs
+     */
+    private function evalInstrsForInit(array $instrs): int|float|Ref
+    {
+        $this->execInstrsForInit($instrs);
+        $result = $this->stack->popValue();
+        return $result;
+    }
+
+    private function execInstr(Instr $instr): ?int
+    {
+        return match ($instr::class) {
+            Instrs\Numeric\F32Abs::class => $this->execInstrNumericF32Abs($instr),
+            Instrs\Numeric\F32Add::class => $this->execInstrNumericF32Add($instr),
+            Instrs\Numeric\F32Ceil::class => $this->execInstrNumericF32Ceil($instr),
+            Instrs\Numeric\F32Const::class => $this->execInstrNumericF32Const($instr),
+            Instrs\Numeric\F32ConvertI32S::class => $this->execInstrNumericF32ConvertI32S($instr),
+            Instrs\Numeric\F32ConvertI32U::class => $this->execInstrNumericF32ConvertI32U($instr),
+            Instrs\Numeric\F32ConvertI64S::class => $this->execInstrNumericF32ConvertI64S($instr),
+            Instrs\Numeric\F32ConvertI64U::class => $this->execInstrNumericF32ConvertI64U($instr),
+            Instrs\Numeric\F32CopySign::class => $this->execInstrNumericF32CopySign($instr),
+            Instrs\Numeric\F32DemoteF64::class => $this->execInstrNumericF32DemoteF64($instr),
+            Instrs\Numeric\F32Div::class => $this->execInstrNumericF32Div($instr),
+            Instrs\Numeric\F32Eq::class => $this->execInstrNumericF32Eq($instr),
+            Instrs\Numeric\F32Floor::class => $this->execInstrNumericF32Floor($instr),
+            Instrs\Numeric\F32Ge::class => $this->execInstrNumericF32Ge($instr),
+            Instrs\Numeric\F32Gt::class => $this->execInstrNumericF32Gt($instr),
+            Instrs\Numeric\F32Le::class => $this->execInstrNumericF32Le($instr),
+            Instrs\Numeric\F32Lt::class => $this->execInstrNumericF32Lt($instr),
+            Instrs\Numeric\F32Max::class => $this->execInstrNumericF32Max($instr),
+            Instrs\Numeric\F32Min::class => $this->execInstrNumericF32Min($instr),
+            Instrs\Numeric\F32Mul::class => $this->execInstrNumericF32Mul($instr),
+            Instrs\Numeric\F32Ne::class => $this->execInstrNumericF32Ne($instr),
+            Instrs\Numeric\F32Nearest::class => $this->execInstrNumericF32Nearest($instr),
+            Instrs\Numeric\F32Neg::class => $this->execInstrNumericF32Neg($instr),
+            Instrs\Numeric\F32ReinterpretI32::class => $this->execInstrNumericF32ReinterpretI32($instr),
+            Instrs\Numeric\F32ReinterpretI64::class => $this->execInstrNumericF32ReinterpretI64($instr),
+            Instrs\Numeric\F32Sqrt::class => $this->execInstrNumericF32Sqrt($instr),
+            Instrs\Numeric\F32Sub::class => $this->execInstrNumericF32Sub($instr),
+            Instrs\Numeric\F32Trunc::class => $this->execInstrNumericF32Trunc($instr),
+            Instrs\Numeric\F64Abs::class => $this->execInstrNumericF64Abs($instr),
+            Instrs\Numeric\F64Add::class => $this->execInstrNumericF64Add($instr),
+            Instrs\Numeric\F64Ceil::class => $this->execInstrNumericF64Ceil($instr),
+            Instrs\Numeric\F64Const::class => $this->execInstrNumericF64Const($instr),
+            Instrs\Numeric\F64ConvertI32S::class => $this->execInstrNumericF64ConvertI32S($instr),
+            Instrs\Numeric\F64ConvertI32U::class => $this->execInstrNumericF64ConvertI32U($instr),
+            Instrs\Numeric\F64ConvertI64S::class => $this->execInstrNumericF64ConvertI64S($instr),
+            Instrs\Numeric\F64ConvertI64U::class => $this->execInstrNumericF64ConvertI64U($instr),
+            Instrs\Numeric\F64CopySign::class => $this->execInstrNumericF64CopySign($instr),
+            Instrs\Numeric\F64Div::class => $this->execInstrNumericF64Div($instr),
+            Instrs\Numeric\F64Eq::class => $this->execInstrNumericF64Eq($instr),
+            Instrs\Numeric\F64Floor::class => $this->execInstrNumericF64Floor($instr),
+            Instrs\Numeric\F64Ge::class => $this->execInstrNumericF64Ge($instr),
+            Instrs\Numeric\F64Gt::class => $this->execInstrNumericF64Gt($instr),
+            Instrs\Numeric\F64Le::class => $this->execInstrNumericF64Le($instr),
+            Instrs\Numeric\F64Lt::class => $this->execInstrNumericF64Lt($instr),
+            Instrs\Numeric\F64Max::class => $this->execInstrNumericF64Max($instr),
+            Instrs\Numeric\F64Min::class => $this->execInstrNumericF64Min($instr),
+            Instrs\Numeric\F64Mul::class => $this->execInstrNumericF64Mul($instr),
+            Instrs\Numeric\F64Ne::class => $this->execInstrNumericF64Ne($instr),
+            Instrs\Numeric\F64Nearest::class => $this->execInstrNumericF64Nearest($instr),
+            Instrs\Numeric\F64Neg::class => $this->execInstrNumericF64Neg($instr),
+            Instrs\Numeric\F64PromoteF32::class => $this->execInstrNumericF64PromoteF32($instr),
+            Instrs\Numeric\F64ReinterpretI32::class => $this->execInstrNumericF64ReinterpretI32($instr),
+            Instrs\Numeric\F64ReinterpretI64::class => $this->execInstrNumericF64ReinterpretI64($instr),
+            Instrs\Numeric\F64Sqrt::class => $this->execInstrNumericF64Sqrt($instr),
+            Instrs\Numeric\F64Sub::class => $this->execInstrNumericF64Sub($instr),
+            Instrs\Numeric\F64Trunc::class => $this->execInstrNumericF64Trunc($instr),
+            Instrs\Numeric\I32Add::class => $this->execInstrNumericI32Add($instr),
+            Instrs\Numeric\I32And::class => $this->execInstrNumericI32And($instr),
+            Instrs\Numeric\I32Clz::class => $this->execInstrNumericI32Clz($instr),
+            Instrs\Numeric\I32Const::class => $this->execInstrNumericI32Const($instr),
+            Instrs\Numeric\I32Ctz::class => $this->execInstrNumericI32Ctz($instr),
+            Instrs\Numeric\I32DivS::class => $this->execInstrNumericI32DivS($instr),
+            Instrs\Numeric\I32DivU::class => $this->execInstrNumericI32DivU($instr),
+            Instrs\Numeric\I32Eq::class => $this->execInstrNumericI32Eq($instr),
+            Instrs\Numeric\I32Eqz::class => $this->execInstrNumericI32Eqz($instr),
+            Instrs\Numeric\I32Extend16S::class => $this->execInstrNumericI32Extend16S($instr),
+            Instrs\Numeric\I32Extend8S::class => $this->execInstrNumericI32Extend8S($instr),
+            Instrs\Numeric\I32GeS::class => $this->execInstrNumericI32GeS($instr),
+            Instrs\Numeric\I32GeU::class => $this->execInstrNumericI32GeU($instr),
+            Instrs\Numeric\I32GtS::class => $this->execInstrNumericI32GtS($instr),
+            Instrs\Numeric\I32GtU::class => $this->execInstrNumericI32GtU($instr),
+            Instrs\Numeric\I32LeS::class => $this->execInstrNumericI32LeS($instr),
+            Instrs\Numeric\I32LeU::class => $this->execInstrNumericI32LeU($instr),
+            Instrs\Numeric\I32LtS::class => $this->execInstrNumericI32LtS($instr),
+            Instrs\Numeric\I32LtU::class => $this->execInstrNumericI32LtU($instr),
+            Instrs\Numeric\I32Mul::class => $this->execInstrNumericI32Mul($instr),
+            Instrs\Numeric\I32Ne::class => $this->execInstrNumericI32Ne($instr),
+            Instrs\Numeric\I32Or::class => $this->execInstrNumericI32Or($instr),
+            Instrs\Numeric\I32Popcnt::class => $this->execInstrNumericI32Popcnt($instr),
+            Instrs\Numeric\I32ReinterpretF32::class => $this->execInstrNumericI32ReinterpretF32($instr),
+            Instrs\Numeric\I32ReinterpretF64::class => $this->execInstrNumericI32ReinterpretF64($instr),
+            Instrs\Numeric\I32RemS::class => $this->execInstrNumericI32RemS($instr),
+            Instrs\Numeric\I32RemU::class => $this->execInstrNumericI32RemU($instr),
+            Instrs\Numeric\I32RotL::class => $this->execInstrNumericI32RotL($instr),
+            Instrs\Numeric\I32RotR::class => $this->execInstrNumericI32RotR($instr),
+            Instrs\Numeric\I32Shl::class => $this->execInstrNumericI32Shl($instr),
+            Instrs\Numeric\I32ShrS::class => $this->execInstrNumericI32ShrS($instr),
+            Instrs\Numeric\I32ShrU::class => $this->execInstrNumericI32ShrU($instr),
+            Instrs\Numeric\I32Sub::class => $this->execInstrNumericI32Sub($instr),
+            Instrs\Numeric\I32TruncF32S::class => $this->execInstrNumericI32TruncF32S($instr),
+            Instrs\Numeric\I32TruncF32U::class => $this->execInstrNumericI32TruncF32U($instr),
+            Instrs\Numeric\I32TruncF64S::class => $this->execInstrNumericI32TruncF64S($instr),
+            Instrs\Numeric\I32TruncF64U::class => $this->execInstrNumericI32TruncF64U($instr),
+            Instrs\Numeric\I32TruncSatF32S::class => $this->execInstrNumericI32TruncSatF32S($instr),
+            Instrs\Numeric\I32TruncSatF32U::class => $this->execInstrNumericI32TruncSatF32U($instr),
+            Instrs\Numeric\I32TruncSatF64S::class => $this->execInstrNumericI32TruncSatF64S($instr),
+            Instrs\Numeric\I32TruncSatF64U::class => $this->execInstrNumericI32TruncSatF64U($instr),
+            Instrs\Numeric\I32WrapI64::class => $this->execInstrNumericI32WrapI64($instr),
+            Instrs\Numeric\I32Xor::class => $this->execInstrNumericI32Xor($instr),
+            Instrs\Numeric\I64Add::class => $this->execInstrNumericI64Add($instr),
+            Instrs\Numeric\I64And::class => $this->execInstrNumericI64And($instr),
+            Instrs\Numeric\I64Clz::class => $this->execInstrNumericI64Clz($instr),
+            Instrs\Numeric\I64Const::class => $this->execInstrNumericI64Const($instr),
+            Instrs\Numeric\I64Ctz::class => $this->execInstrNumericI64Ctz($instr),
+            Instrs\Numeric\I64DivS::class => $this->execInstrNumericI64DivS($instr),
+            Instrs\Numeric\I64DivU::class => $this->execInstrNumericI64DivU($instr),
+            Instrs\Numeric\I64Eq::class => $this->execInstrNumericI64Eq($instr),
+            Instrs\Numeric\I64Eqz::class => $this->execInstrNumericI64Eqz($instr),
+            Instrs\Numeric\I64Extend16S::class => $this->execInstrNumericI64Extend16S($instr),
+            Instrs\Numeric\I64Extend32S::class => $this->execInstrNumericI64Extend32S($instr),
+            Instrs\Numeric\I64Extend8S::class => $this->execInstrNumericI64Extend8S($instr),
+            Instrs\Numeric\I64ExtendI32S::class => $this->execInstrNumericI64ExtendI32S($instr),
+            Instrs\Numeric\I64ExtendI32U::class => $this->execInstrNumericI64ExtendI32U($instr),
+            Instrs\Numeric\I64GeS::class => $this->execInstrNumericI64GeS($instr),
+            Instrs\Numeric\I64GeU::class => $this->execInstrNumericI64GeU($instr),
+            Instrs\Numeric\I64GtS::class => $this->execInstrNumericI64GtS($instr),
+            Instrs\Numeric\I64GtU::class => $this->execInstrNumericI64GtU($instr),
+            Instrs\Numeric\I64LeS::class => $this->execInstrNumericI64LeS($instr),
+            Instrs\Numeric\I64LeU::class => $this->execInstrNumericI64LeU($instr),
+            Instrs\Numeric\I64LtS::class => $this->execInstrNumericI64LtS($instr),
+            Instrs\Numeric\I64LtU::class => $this->execInstrNumericI64LtU($instr),
+            Instrs\Numeric\I64Mul::class => $this->execInstrNumericI64Mul($instr),
+            Instrs\Numeric\I64Ne::class => $this->execInstrNumericI64Ne($instr),
+            Instrs\Numeric\I64Or::class => $this->execInstrNumericI64Or($instr),
+            Instrs\Numeric\I64Popcnt::class => $this->execInstrNumericI64Popcnt($instr),
+            Instrs\Numeric\I64ReinterpretF32::class => $this->execInstrNumericI64ReinterpretF32($instr),
+            Instrs\Numeric\I64ReinterpretF64::class => $this->execInstrNumericI64ReinterpretF64($instr),
+            Instrs\Numeric\I64RemS::class => $this->execInstrNumericI64RemS($instr),
+            Instrs\Numeric\I64RemU::class => $this->execInstrNumericI64RemU($instr),
+            Instrs\Numeric\I64RotL::class => $this->execInstrNumericI64RotL($instr),
+            Instrs\Numeric\I64RotR::class => $this->execInstrNumericI64RotR($instr),
+            Instrs\Numeric\I64Shl::class => $this->execInstrNumericI64Shl($instr),
+            Instrs\Numeric\I64ShrS::class => $this->execInstrNumericI64ShrS($instr),
+            Instrs\Numeric\I64ShrU::class => $this->execInstrNumericI64ShrU($instr),
+            Instrs\Numeric\I64Sub::class => $this->execInstrNumericI64Sub($instr),
+            Instrs\Numeric\I64TruncF32S::class => $this->execInstrNumericI64TruncF32S($instr),
+            Instrs\Numeric\I64TruncF32U::class => $this->execInstrNumericI64TruncF32U($instr),
+            Instrs\Numeric\I64TruncF64S::class => $this->execInstrNumericI64TruncF64S($instr),
+            Instrs\Numeric\I64TruncF64U::class => $this->execInstrNumericI64TruncF64U($instr),
+            Instrs\Numeric\I64TruncSatF32S::class => $this->execInstrNumericI64TruncSatF32S($instr),
+            Instrs\Numeric\I64TruncSatF32U::class => $this->execInstrNumericI64TruncSatF32U($instr),
+            Instrs\Numeric\I64TruncSatF64S::class => $this->execInstrNumericI64TruncSatF64S($instr),
+            Instrs\Numeric\I64TruncSatF64U::class => $this->execInstrNumericI64TruncSatF64U($instr),
+            Instrs\Numeric\I64Xor::class => $this->execInstrNumericI64Xor($instr),
+            Instrs\Reference\RefFunc::class => $this->execInstrReferenceRefFunc($instr),
+            Instrs\Reference\RefIsNull::class => $this->execInstrReferenceRefIsNull($instr),
+            Instrs\Reference\RefNull::class => $this->execInstrReferenceRefNull($instr),
+            Instrs\Parametric\Drop::class => $this->execInstrParametricDrop($instr),
+            Instrs\Parametric\Select::class => $this->execInstrParametricSelect($instr),
+            Instrs\Variable\GlobalGet::class => $this->execInstrVariableGlobalGet($instr),
+            Instrs\Variable\GlobalSet::class => $this->execInstrVariableGlobalSet($instr),
+            Instrs\Variable\LocalGet::class => $this->execInstrVariableLocalGet($instr),
+            Instrs\Variable\LocalSet::class => $this->execInstrVariableLocalSet($instr),
+            Instrs\Variable\LocalTee::class => $this->execInstrVariableLocalTee($instr),
+            Instrs\Table\ElemDrop::class => $this->execInstrTableElemDrop($instr),
+            Instrs\Table\TableCopy::class => $this->execInstrTableTableCopy($instr),
+            Instrs\Table\TableFill::class => $this->execInstrTableTableFill($instr),
+            Instrs\Table\TableGet::class => $this->execInstrTableTableGet($instr),
+            Instrs\Table\TableGrow::class => $this->execInstrTableTableGrow($instr),
+            Instrs\Table\TableInit::class => $this->execInstrTableTableInit($instr),
+            Instrs\Table\TableSet::class => $this->execInstrTableTableSet($instr),
+            Instrs\Table\TableSize::class => $this->execInstrTableTableSize($instr),
+            Instrs\Memory\DataDrop::class => $this->execInstrMemoryDataDrop($instr),
+            Instrs\Memory\F32Load::class => $this->execInstrMemoryF32Load($instr),
+            Instrs\Memory\F32Store::class => $this->execInstrMemoryF32Store($instr),
+            Instrs\Memory\F64Load::class => $this->execInstrMemoryF64Load($instr),
+            Instrs\Memory\F64Store::class => $this->execInstrMemoryF64Store($instr),
+            Instrs\Memory\I32Load::class => $this->execInstrMemoryI32Load($instr),
+            Instrs\Memory\I32Load16S::class => $this->execInstrMemoryI32Load16S($instr),
+            Instrs\Memory\I32Load16U::class => $this->execInstrMemoryI32Load16U($instr),
+            Instrs\Memory\I32Load8S::class => $this->execInstrMemoryI32Load8S($instr),
+            Instrs\Memory\I32Load8U::class => $this->execInstrMemoryI32Load8U($instr),
+            Instrs\Memory\I32Store::class => $this->execInstrMemoryI32Store($instr),
+            Instrs\Memory\I32Store16::class => $this->execInstrMemoryI32Store16($instr),
+            Instrs\Memory\I32Store8::class => $this->execInstrMemoryI32Store8($instr),
+            Instrs\Memory\I64Load::class => $this->execInstrMemoryI64Load($instr),
+            Instrs\Memory\I64Load16S::class => $this->execInstrMemoryI64Load16S($instr),
+            Instrs\Memory\I64Load16U::class => $this->execInstrMemoryI64Load16U($instr),
+            Instrs\Memory\I64Load32S::class => $this->execInstrMemoryI64Load32S($instr),
+            Instrs\Memory\I64Load32U::class => $this->execInstrMemoryI64Load32U($instr),
+            Instrs\Memory\I64Load8S::class => $this->execInstrMemoryI64Load8S($instr),
+            Instrs\Memory\I64Load8U::class => $this->execInstrMemoryI64Load8U($instr),
+            Instrs\Memory\I64Store::class => $this->execInstrMemoryI64Store($instr),
+            Instrs\Memory\I64Store16::class => $this->execInstrMemoryI64Store16($instr),
+            Instrs\Memory\I64Store32::class => $this->execInstrMemoryI64Store32($instr),
+            Instrs\Memory\I64Store8::class => $this->execInstrMemoryI64Store8($instr),
+            Instrs\Memory\MemoryCopy::class => $this->execInstrMemoryMemoryCopy($instr),
+            Instrs\Memory\MemoryFill::class => $this->execInstrMemoryMemoryFill($instr),
+            Instrs\Memory\MemoryGrow::class => $this->execInstrMemoryMemoryGrow($instr),
+            Instrs\Memory\MemoryInit::class => $this->execInstrMemoryMemoryInit($instr),
+            Instrs\Memory\MemorySize::class => $this->execInstrMemoryMemorySize($instr),
+            Instrs\Control\Block::class => $this->execInstrControlBlock($instr),
+            Instrs\Control\Br::class => $this->execInstrControlBr($instr),
+            Instrs\Control\BrIf::class => $this->execInstrControlBrIf($instr),
+            Instrs\Control\BrTable::class => $this->execInstrControlBrTable($instr),
+            Instrs\Control\Call::class => $this->execInstrControlCall($instr),
+            Instrs\Control\CallIndirect::class => $this->execInstrControlCallIndirect($instr),
+            Instrs\Control\Else_::class => $this->execInstrControlElse_($instr),
+            Instrs\Control\End::class => $this->execInstrControlEnd($instr),
+            Instrs\Control\If_::class => $this->execInstrControlIf_($instr),
+            Instrs\Control\Loop::class => $this->execInstrControlLoop($instr),
+            Instrs\Control\Nop::class => $this->execInstrControlNop($instr),
+            Instrs\Control\Return_::class => $this->execInstrControlReturn_($instr),
+            Instrs\Control\Unreachable::class => $this->execInstrControlUnreachable($instr),
+            default => throw new RuntimeException("invalid instruction"),
+        };
+    }
+
+    private function execInstrNumericF32Abs(Instrs\Numeric\F32Abs $instr): void
+    {
+        $v = $this->stack->popFloat();
+        $this->stack->pushValue(abs($v));
+    }
+
+    private function execInstrNumericF32Add(Instrs\Numeric\F32Add $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushValue(NumericOps::truncateF64ToF32($c1 + $c2));
+    }
+
+    private function execInstrNumericF32Ceil(Instrs\Numeric\F32Ceil $instr): void
+    {
+        $v = $this->stack->popFloat();
+        $this->stack->pushValue(ceil($v));
+    }
+
+    private function execInstrNumericF32Const(Instrs\Numeric\F32Const $instr): void
+    {
+        $this->stack->pushValue($instr->value);
+    }
+
+    private function execInstrNumericF32ConvertI32S(Instrs\Numeric\F32ConvertI32S $instr): void
+    {
+        $v = $this->stack->popInt();
+        $this->stack->pushValue(NumericOps::truncateF64ToF32((float) $v));
+    }
+
+    private function execInstrNumericF32ConvertI32U(Instrs\Numeric\F32ConvertI32U $instr): void
+    {
+        $v = NumericOps::convertS32ToU32($this->stack->popInt());
+        $this->stack->pushValue(NumericOps::truncateF64ToF32((float) $v));
+    }
+
+    private function execInstrNumericF32ConvertI64S(Instrs\Numeric\F32ConvertI64S $instr): void
+    {
+        $v = $this->stack->popInt();
+        $this->stack->pushValue(NumericOps::truncateF64ToF32((float) $v));
+    }
+
+    private function execInstrNumericF32ConvertI64U(Instrs\Numeric\F32ConvertI64U $instr): void
+    {
+        $v = $this->stack->popInt();
+        $this->stack->pushValue(NumericOps::truncateF64ToF32((float) $v));
+    }
+
+    private function execInstrNumericF32CopySign(Instrs\Numeric\F32CopySign $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $c1Sign = NumericOps::getFloatSign($c1);
+        $c2Sign = NumericOps::getFloatSign($c2);
+        $this->stack->pushValue($c1Sign === $c2Sign ? $c1 : -$c1);
+    }
+
+    private function execInstrNumericF32DemoteF64(Instrs\Numeric\F32DemoteF64 $instr): void
+    {
+        $v = $this->stack->popFloat();
+        $this->stack->pushValue($v);
+    }
+
+    private function execInstrNumericF32Div(Instrs\Numeric\F32Div $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushValue(NumericOps::truncateF64ToF32(fdiv($c1, $c2)));
+    }
+
+    private function execInstrNumericF32Eq(Instrs\Numeric\F32Eq $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushBool($c1 === $c2);
+    }
+
+    private function execInstrNumericF32Floor(Instrs\Numeric\F32Floor $instr): void
+    {
+        $v = $this->stack->popFloat();
+        $this->stack->pushValue(floor($v));
+    }
+
+    private function execInstrNumericF32Ge(Instrs\Numeric\F32Ge $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushBool($c1 >= $c2);
+    }
+
+    private function execInstrNumericF32Gt(Instrs\Numeric\F32Gt $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushBool($c1 > $c2);
+    }
+
+    private function execInstrNumericF32Le(Instrs\Numeric\F32Le $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushBool($c1 <= $c2);
+    }
+
+    private function execInstrNumericF32Lt(Instrs\Numeric\F32Lt $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushBool($c1 < $c2);
+    }
+
+    private function execInstrNumericF32Max(Instrs\Numeric\F32Max $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        if (is_nan($c1) || is_nan($c2)) {
+            // PHP's standard max() handles NaNs in diffrent way than WebAssembly spec does.
+            $this->stack->pushValue(NAN);
+            return;
+        }
+        $this->stack->pushValue(max($c1, $c2));
+    }
+
+    private function execInstrNumericF32Min(Instrs\Numeric\F32Min $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        if (is_nan($c1) || is_nan($c2)) {
+            // PHP's standard min() handles NaNs in diffrent way than WebAssembly spec does.
+            $this->stack->pushValue(NAN);
+            return;
+        }
+        $this->stack->pushValue(min($c1, $c2));
+    }
+
+    private function execInstrNumericF32Mul(Instrs\Numeric\F32Mul $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushValue(NumericOps::truncateF64ToF32($c1 * $c2));
+    }
+
+    private function execInstrNumericF32Ne(Instrs\Numeric\F32Ne $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushBool($c1 !== $c2);
+    }
+
+    private function execInstrNumericF32Nearest(Instrs\Numeric\F32Nearest $instr): void
+    {
+        $v = $this->stack->popFloat();
+        $this->stack->pushValue(round($v, mode: PHP_ROUND_HALF_EVEN));
+    }
+
+    private function execInstrNumericF32Neg(Instrs\Numeric\F32Neg $instr): void
+    {
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushValue(-$c1);
+    }
+
+    private function execInstrNumericF32ReinterpretI32(Instrs\Numeric\F32ReinterpretI32 $instr): void
+    {
+        $v = $this->stack->popInt();
+        $this->stack->pushValue(NumericOps::reinterpretI32AsF32($v));
+    }
+
+    private function execInstrNumericF32ReinterpretI64(Instrs\Numeric\F32ReinterpretI64 $instr): void
+    {
+        $v = $this->stack->popInt();
+        $this->stack->pushValue(NumericOps::reinterpretI64AsF32($v));
+    }
+
+    private function execInstrNumericF32Sqrt(Instrs\Numeric\F32Sqrt $instr): void
+    {
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushValue(NumericOps::truncateF64ToF32(sqrt($c1)));
+    }
+
+    private function execInstrNumericF32Sub(Instrs\Numeric\F32Sub $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushValue(NumericOps::truncateF64ToF32($c1 - $c2));
+    }
+
+    private function execInstrNumericF32Trunc(Instrs\Numeric\F32Trunc $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if ($v < 0) {
+            $this->stack->pushValue(NumericOps::truncateF64ToF32(ceil($v)));
+        } else {
+            $this->stack->pushValue(NumericOps::truncateF64ToF32(floor($v)));
+        }
+    }
+
+    private function execInstrNumericF64Abs(Instrs\Numeric\F64Abs $instr): void
+    {
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushValue(abs($c1));
+    }
+
+    private function execInstrNumericF64Add(Instrs\Numeric\F64Add $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushValue($c1 + $c2);
+    }
+
+    private function execInstrNumericF64Ceil(Instrs\Numeric\F64Ceil $instr): void
+    {
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushValue(ceil($c1));
+    }
+
+    private function execInstrNumericF64Const(Instrs\Numeric\F64Const $instr): void
+    {
+        $this->stack->pushValue($instr->value);
+    }
+
+    private function execInstrNumericF64ConvertI32S(Instrs\Numeric\F64ConvertI32S $instr): void
+    {
+        $c = $this->stack->popInt();
+        $this->stack->pushValue((float) $c);
+    }
+
+    private function execInstrNumericF64ConvertI32U(Instrs\Numeric\F64ConvertI32U $instr): void
+    {
+        $c = $this->stack->popInt();
+        $this->stack->pushValue((float) $c);
+    }
+
+    private function execInstrNumericF64ConvertI64S(Instrs\Numeric\F64ConvertI64S $instr): void
+    {
+        $c = $this->stack->popInt();
+        $this->stack->pushValue((float) $c);
+    }
+
+    private function execInstrNumericF64ConvertI64U(Instrs\Numeric\F64ConvertI64U $instr): void
+    {
+        $c = $this->stack->popInt();
+        $this->stack->pushValue((float) $c);
+    }
+
+    private function execInstrNumericF64CopySign(Instrs\Numeric\F64CopySign $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $c1Sign = NumericOps::getFloatSign($c1);
+        $c2Sign = NumericOps::getFloatSign($c2);
+        $this->stack->pushValue($c1Sign === $c2Sign ? $c1 : -$c1);
+    }
+
+    private function execInstrNumericF64Div(Instrs\Numeric\F64Div $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushValue(fdiv($c1, $c2));
+    }
+
+    private function execInstrNumericF64Eq(Instrs\Numeric\F64Eq $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushBool($c1 === $c2);
+    }
+
+    private function execInstrNumericF64Floor(Instrs\Numeric\F64Floor $instr): void
+    {
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushValue(floor($c1));
+    }
+
+    private function execInstrNumericF64Ge(Instrs\Numeric\F64Ge $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushBool($c1 >= $c2);
+    }
+
+    private function execInstrNumericF64Gt(Instrs\Numeric\F64Gt $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushBool($c1 > $c2);
+    }
+
+    private function execInstrNumericF64Le(Instrs\Numeric\F64Le $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushBool($c1 <= $c2);
+    }
+
+    private function execInstrNumericF64Lt(Instrs\Numeric\F64Lt $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushBool($c1 < $c2);
+    }
+
+    private function execInstrNumericF64Max(Instrs\Numeric\F64Max $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        if (is_nan($c1) || is_nan($c2)) {
+            // PHP's standard max() handles NaNs in diffrent way than WebAssembly spec does.
+            $this->stack->pushValue(NAN);
+            return;
+        }
+        $this->stack->pushValue(max($c1, $c2));
+    }
+
+    private function execInstrNumericF64Min(Instrs\Numeric\F64Min $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        if (is_nan($c1) || is_nan($c2)) {
+            // PHP's standard min() handles NaNs in diffrent way than WebAssembly spec does.
+            $this->stack->pushValue(NAN);
+            return;
+        }
+        $this->stack->pushValue(min($c1, $c2));
+    }
+
+    private function execInstrNumericF64Mul(Instrs\Numeric\F64Mul $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushValue($c1 * $c2);
+    }
+
+    private function execInstrNumericF64Ne(Instrs\Numeric\F64Ne $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushBool($c1 !== $c2);
+    }
+
+    private function execInstrNumericF64Nearest(Instrs\Numeric\F64Nearest $instr): void
+    {
+        $v = $this->stack->popFloat();
+        $this->stack->pushValue(round($v, mode: PHP_ROUND_HALF_EVEN));
+    }
+
+    private function execInstrNumericF64Neg(Instrs\Numeric\F64Neg $instr): void
+    {
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushValue(-$c1);
+    }
+
+    private function execInstrNumericF64PromoteF32(Instrs\Numeric\F64PromoteF32 $instr): void
+    {
+        $v = $this->stack->popFloat();
+        $this->stack->pushValue($v);
+    }
+
+    private function execInstrNumericF64ReinterpretI32(Instrs\Numeric\F64ReinterpretI32 $instr): void
+    {
+        $v = $this->stack->popInt();
+        $this->stack->pushValue(NumericOps::reinterpretI32AsF64($v));
+    }
+
+    private function execInstrNumericF64ReinterpretI64(Instrs\Numeric\F64ReinterpretI64 $instr): void
+    {
+        $v = $this->stack->popInt();
+        $this->stack->pushValue(NumericOps::reinterpretI64AsF64($v));
+    }
+
+    private function execInstrNumericF64Sqrt(Instrs\Numeric\F64Sqrt $instr): void
+    {
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushValue(sqrt($c1));
+    }
+
+    private function execInstrNumericF64Sub(Instrs\Numeric\F64Sub $instr): void
+    {
+        $c2 = $this->stack->popFloat();
+        $c1 = $this->stack->popFloat();
+        $this->stack->pushValue($c1 - $c2);
+    }
+
+    private function execInstrNumericF64Trunc(Instrs\Numeric\F64Trunc $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if ($v < 0) {
+            $this->stack->pushValue(ceil($v));
+        } else {
+            $this->stack->pushValue(floor($v));
+        }
+    }
+
+    private function execInstrNumericI32Add(Instrs\Numeric\I32Add $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushValue(NumericOps::convertU32ToS32(($c1 + $c2) & 0xFFFFFFFF));
+    }
+
+    private function execInstrNumericI32And(Instrs\Numeric\I32And $instr): void
+    {
+        $c2 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $c1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $this->stack->pushValue(NumericOps::convertU32ToS32(($c1 & $c2) & 0xFFFFFFFF));
+    }
+
+    private function execInstrNumericI32Clz(Instrs\Numeric\I32Clz $instr): void
+    {
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $leadingZeros = 0;
+        for ($j = 31; 0 <= $j; $j--) {
+            if (($i & (1 << $j)) === 0) {
+                $leadingZeros++;
+            } else {
+                break;
+            }
+        }
+        $this->stack->pushValue($leadingZeros);
+    }
+
+    private function execInstrNumericI32Const(Instrs\Numeric\I32Const $instr): void
+    {
+        $this->stack->pushValue($instr->value);
+    }
+
+    private function execInstrNumericI32Ctz(Instrs\Numeric\I32Ctz $instr): void
+    {
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $trailingZeros = 0;
+        for ($j = 0; $j < 32; $j++) {
+            if (($i & (1 << $j)) === 0) {
+                $trailingZeros++;
+            } else {
+                break;
+            }
+        }
+        $this->stack->pushValue($trailingZeros);
+    }
+
+    private function execInstrNumericI32DivS(Instrs\Numeric\I32DivS $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        if ($c2 === 0) {
+            throw new TrapException("i32.div_s: divide by zero", trapKind: TrapKind::DivideByZero);
+        }
+        if ($c1 === -2147483648 && $c2 === -1) {
+            throw new TrapException("i32.div_s: overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        $this->stack->pushValue(intdiv($c1, $c2));
+    }
+
+    private function execInstrNumericI32DivU(Instrs\Numeric\I32DivU $instr): void
+    {
+        $c2 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $c1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        if ($c2 === 0) {
+            throw new TrapException("i32.div_u: divide by zero", trapKind: TrapKind::DivideByZero);
+        }
+        $this->stack->pushValue(NumericOps::convertU32ToS32(intdiv($c1, $c2)));
+    }
+
+    private function execInstrNumericI32Eq(Instrs\Numeric\I32Eq $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushBool($c1 === $c2);
+    }
+
+    private function execInstrNumericI32Eqz(Instrs\Numeric\I32Eqz $instr): void
+    {
+        $c1 = $this->stack->popInt();
+        $this->stack->pushBool($c1 === 0);
+    }
+
+    private function execInstrNumericI32Extend16S(Instrs\Numeric\I32Extend16S $instr): void
+    {
+        $c1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $c2 = $c1 & 0xFFFF;
+        $result = unpack('s', pack('S', $c2));
+        assert($result !== false);
+        $this->stack->pushValue($result[1]);
+    }
+
+    private function execInstrNumericI32Extend8S(Instrs\Numeric\I32Extend8S $instr): void
+    {
+        $c1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $c2 = $c1 & 0xFF;
+        $result = unpack('c', pack('C', $c2));
+        assert($result !== false);
+        $this->stack->pushValue($result[1]);
+    }
+
+    private function execInstrNumericI32GeS(Instrs\Numeric\I32GeS $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushBool($c1 >= $c2);
+    }
+
+    private function execInstrNumericI32GeU(Instrs\Numeric\I32GeU $instr): void
+    {
+        $c2 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $c1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $this->stack->pushBool($c1 >= $c2);
+    }
+
+    private function execInstrNumericI32GtS(Instrs\Numeric\I32GtS $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushBool($c1 > $c2);
+    }
+
+    private function execInstrNumericI32GtU(Instrs\Numeric\I32GtU $instr): void
+    {
+        $c2 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $c1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $this->stack->pushBool($c1 > $c2);
+    }
+
+    private function execInstrNumericI32LeS(Instrs\Numeric\I32LeS $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushBool($c1 <= $c2);
+    }
+
+    private function execInstrNumericI32LeU(Instrs\Numeric\I32LeU $instr): void
+    {
+        $c2 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $c1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $this->stack->pushBool($c1 <= $c2);
+    }
+
+    private function execInstrNumericI32LtS(Instrs\Numeric\I32LtS $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushBool($c1 < $c2);
+    }
+
+    private function execInstrNumericI32LtU(Instrs\Numeric\I32LtU $instr): void
+    {
+        $c2 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $c1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $this->stack->pushBool($c1 < $c2);
+    }
+
+    private function execInstrNumericI32Mul(Instrs\Numeric\I32Mul $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushValue(NumericOps::convertU32ToS32(($c1 * $c2) & 0xFFFFFFFF));
+    }
+
+    private function execInstrNumericI32Ne(Instrs\Numeric\I32Ne $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushBool($c1 !== $c2);
+    }
+
+    private function execInstrNumericI32Or(Instrs\Numeric\I32Or $instr): void
+    {
+        $c2 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $c1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $this->stack->pushValue(NumericOps::convertU32ToS32(($c1 | $c2) & 0xFFFFFFFF));
+    }
+
+    private function execInstrNumericI32Popcnt(Instrs\Numeric\I32Popcnt $instr): void
+    {
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $popcnt = 0;
+        for ($j = 0; $j < 32; $j++) {
+            if (($i & (1 << $j)) !== 0) {
+                $popcnt++;
+            }
+        }
+        $this->stack->pushValue($popcnt);
+    }
+
+    private function execInstrNumericI32ReinterpretF32(Instrs\Numeric\I32ReinterpretF32 $instr): void
+    {
+        $v = $this->stack->popFloat();
+        $this->stack->pushValue(NumericOps::reinterpretF32AsI32($v));
+    }
+
+    private function execInstrNumericI32ReinterpretF64(Instrs\Numeric\I32ReinterpretF64 $instr): void
+    {
+        $v = $this->stack->popFloat();
+        $this->stack->pushValue(NumericOps::reinterpretF64AsI32($v));
+    }
+
+    private function execInstrNumericI32RemS(Instrs\Numeric\I32RemS $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        if ($c2 === 0) {
+            throw new TrapException("i32.rem_s: divide by zero or overflow", trapKind: TrapKind::DivideByZero);
+        }
+        $this->stack->pushValue($c1 % $c2);
+    }
+
+    private function execInstrNumericI32RemU(Instrs\Numeric\I32RemU $instr): void
+    {
+        $c2 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $c1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        if ($c2 === 0) {
+            throw new TrapException("i32.rem_u: divide by zero", trapKind: TrapKind::DivideByZero);
+        }
+        $this->stack->pushValue(NumericOps::convertU32ToS32($c1 % $c2));
+    }
+
+    private function execInstrNumericI32RotL(Instrs\Numeric\I32RotL $instr): void
+    {
+        $i2 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $i1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $k = $i2 % 32;
+        $this->stack->pushValue(NumericOps::convertU32ToS32((($i1 << $k) | ($i1 >> (32 - $k))) & 0xFFFFFFFF));
+    }
+
+    private function execInstrNumericI32RotR(Instrs\Numeric\I32RotR $instr): void
+    {
+        $i2 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $i1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $k = $i2 % 32;
+        $this->stack->pushValue(NumericOps::convertU32ToS32((($i1 >> $k) | ($i1 << (32 - $k))) & 0xFFFFFFFF));
+    }
+
+    private function execInstrNumericI32Shl(Instrs\Numeric\I32Shl $instr): void
+    {
+        $c2 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $k = $c2 % 32;
+        $c1 = $this->stack->popInt();
+        $this->stack->pushValue(NumericOps::convertU32ToS32(($c1 << $k) & 0xFFFFFFFF));
+    }
+
+    private function execInstrNumericI32ShrS(Instrs\Numeric\I32ShrS $instr): void
+    {
+        $c2 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $k = $c2 % 32;
+        $c1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $signed = $c1 & 0x80000000;
+        if ($signed !== 0) {
+            $result = $c1;
+            for ($i = 0; $i < $k; $i++) {
+                $result = ($result >> 1) | 0x80000000;
+            }
+            $this->stack->pushValue(NumericOps::convertU32ToS32($result));
+        } else {
+            $this->stack->pushValue($c1 >> $k);
+        }
+    }
+
+    private function execInstrNumericI32ShrU(Instrs\Numeric\I32ShrU $instr): void
+    {
+        $c2 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $k = $c2 % 32;
+        $c1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $this->stack->pushValue(NumericOps::convertU32ToS32($c1 >> $k));
+    }
+
+    private function execInstrNumericI32Sub(Instrs\Numeric\I32Sub $instr): void
+    {
+        $c2 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $c1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $c2Neg = ((~$c2 & 0xFFFFFFFF) + 1) & 0xFFFFFFFF;
+        $this->stack->pushValue(NumericOps::convertU32ToS32(($c1 + $c2Neg) & 0xFFFFFFFF));
+    }
+
+    private function execInstrNumericI32TruncF32S(Instrs\Numeric\I32TruncF32S $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if (is_nan($v)) {
+            throw new TrapException($instr::opName() . ": invalid conversion", trapKind: TrapKind::InvalidConversionToInteger);
+        }
+        if (is_infinite($v)) {
+            throw new TrapException($instr::opName() . ": overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        if ($v <= -2147483649.0 || 2147483648.0 <= $v) {
+            throw new TrapException($instr::opName() . ": overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        $this->stack->pushValue((int) $v);
+    }
+
+    private function execInstrNumericI32TruncF32U(Instrs\Numeric\I32TruncF32U $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if (is_nan($v)) {
+            throw new TrapException($instr::opName() . ": invalid conversion", trapKind: TrapKind::InvalidConversionToInteger);
+        }
+        if (is_infinite($v)) {
+            throw new TrapException($instr::opName() . ": overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        if ($v <= -1.0 || 4294967296.0 <= $v) {
+            throw new TrapException($instr::opName() . ": overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        $this->stack->pushValue(NumericOps::convertU32ToS32((int) $v));
+    }
+
+    private function execInstrNumericI32TruncF64S(Instrs\Numeric\I32TruncF64S $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if (is_nan($v)) {
+            throw new TrapException($instr::opName() . ": invalid conversion", trapKind: TrapKind::InvalidConversionToInteger);
+        }
+        if (is_infinite($v)) {
+            throw new TrapException($instr::opName() . ": overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        if ($v <= -2147483649.0 || 2147483648.0 <= $v) {
+            throw new TrapException($instr::opName() . ": overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        $this->stack->pushValue((int) $v);
+    }
+
+    private function execInstrNumericI32TruncF64U(Instrs\Numeric\I32TruncF64U $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if (is_nan($v)) {
+            throw new TrapException($instr::opName() . ": invalid conversion", trapKind: TrapKind::InvalidConversionToInteger);
+        }
+        if (is_infinite($v)) {
+            throw new TrapException($instr::opName() . ": overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        if ($v <= -1.0 || 4294967296.0 <= $v) {
+            throw new TrapException($instr::opName() . ": overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        $this->stack->pushValue(NumericOps::convertU32ToS32((int) $v));
+    }
+
+    private function execInstrNumericI32TruncSatF32S(Instrs\Numeric\I32TruncSatF32S $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if ($v < -2147483648.0) {
+            $this->stack->pushValue(-2147483648);
+        } elseif ($v > 2147483647.0) {
+            $this->stack->pushValue(2147483647);
+        } else {
+            $this->stack->pushValue((int) $v);
+        }
+    }
+
+    private function execInstrNumericI32TruncSatF32U(Instrs\Numeric\I32TruncSatF32U $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if ($v < 0.0) {
+            $this->stack->pushValue(0);
+        } elseif ($v > 4294967295.0) {
+            $this->stack->pushValue(4294967295);
+        } else {
+            $this->stack->pushValue((int) $v);
+        }
+    }
+
+    private function execInstrNumericI32TruncSatF64S(Instrs\Numeric\I32TruncSatF64S $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if ($v < -2147483648.0) {
+            $this->stack->pushValue(-2147483648);
+        } elseif ($v > 2147483647.0) {
+            $this->stack->pushValue(2147483647);
+        } else {
+            $this->stack->pushValue((int) $v);
+        }
+    }
+
+    private function execInstrNumericI32TruncSatF64U(Instrs\Numeric\I32TruncSatF64U $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if ($v < 0.0) {
+            $this->stack->pushValue(0);
+        } elseif ($v > 4294967295.0) {
+            $this->stack->pushValue(4294967295);
+        } else {
+            $this->stack->pushValue((int) $v);
+        }
+    }
+
+    private function execInstrNumericI32WrapI64(Instrs\Numeric\I32WrapI64 $instr): void
+    {
+        $c1 = $this->stack->popInt();
+        $this->stack->pushValue(NumericOps::convertU32ToS32($c1 & 0xFFFFFFFF));
+    }
+
+    private function execInstrNumericI32Xor(Instrs\Numeric\I32Xor $instr): void
+    {
+        $c2 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $c1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $this->stack->pushValue(NumericOps::convertU32ToS32(($c1 ^ $c2) & 0xFFFFFFFF));
+    }
+
+    private function execInstrNumericI64Add(Instrs\Numeric\I64Add $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $result = NumericOps::bigIntToPhpInt(bcadd((string)$c1, (string)$c2));
+        $this->stack->pushValue($result);
+    }
+
+    private function execInstrNumericI64And(Instrs\Numeric\I64And $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushValue($c1 & $c2);
+    }
+
+    private function execInstrNumericI64Clz(Instrs\Numeric\I64Clz $instr): void
+    {
+        $i = $this->stack->popInt();
+        $leadingZeros = 0;
+        for ($j = 63; 0 <= $j; $j--) {
+            if ($j === 63) {
+                if ($i < 0) {
+                    break;
+                } else {
+                    $leadingZeros++;
+                }
+            } else {
+                if (($i & (1 << $j)) === 0) {
+                    $leadingZeros++;
+                } else {
+                    break;
+                }
+            }
+        }
+        $this->stack->pushValue($leadingZeros);
+    }
+
+    private function execInstrNumericI64Const(Instrs\Numeric\I64Const $instr): void
+    {
+        $this->stack->pushValue($instr->value);
+    }
+
+    private function execInstrNumericI64Ctz(Instrs\Numeric\I64Ctz $instr): void
+    {
+        $i = $this->stack->popInt();
+        $trailingZeros = 0;
+        for ($j = 0; $j < 64; $j++) {
+            if ($j === 63) {
+                if ($i >= 0) {
+                    $trailingZeros++;
+                }
+            } else {
+                if (($i & (1 << $j)) === 0) {
+                    $trailingZeros++;
+                } else {
+                    break;
+                }
+            }
+        }
+        $this->stack->pushValue($trailingZeros);
+    }
+
+    private function execInstrNumericI64DivS(Instrs\Numeric\I64DivS $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        if ($c2 === 0) {
+            throw new TrapException("i64.div_s: divide by zero", trapKind: TrapKind::DivideByZero);
+        }
+        if ($c1 === PHP_INT_MIN && $c2 === -1) {
+            throw new TrapException("i64.div_s: overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        $this->stack->pushValue(intdiv($c1, $c2));
+    }
+
+    private function execInstrNumericI64DivU(Instrs\Numeric\I64DivU $instr): void
+    {
+        $c2 = NumericOps::convertS64ToBigUInt($this->stack->popInt());
+        $c1 = NumericOps::convertS64ToBigUInt($this->stack->popInt());
+        if ($c2 === '0') {
+            throw new TrapException("i64.div_u: divide by zero", trapKind: TrapKind::DivideByZero);
+        }
+        $this->stack->pushValue(NumericOps::bigIntToPhpInt(bcdiv($c1, $c2, 0)));
+    }
+
+    private function execInstrNumericI64Eq(Instrs\Numeric\I64Eq $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushBool($c1 === $c2);
+    }
+
+    private function execInstrNumericI64Eqz(Instrs\Numeric\I64Eqz $instr): void
+    {
+        $c1 = $this->stack->popInt();
+        $this->stack->pushBool($c1 === 0);
+    }
+
+    private function execInstrNumericI64Extend16S(Instrs\Numeric\I64Extend16S $instr): void
+    {
+        $c1 = $this->stack->popInt();
+        $c2 = $c1 & 0xFFFF;
+        $result = unpack('s', pack('S', $c2));
+        assert($result !== false);
+        $this->stack->pushValue($result[1]);
+    }
+
+    private function execInstrNumericI64Extend32S(Instrs\Numeric\I64Extend32S $instr): void
+    {
+        $c1 = $this->stack->popInt();
+        $c2 = $c1 & 0xFFFFFFFF;
+        $result = unpack('l', pack('L', $c2));
+        assert($result !== false);
+        $this->stack->pushValue($result[1]);
+    }
+
+    private function execInstrNumericI64Extend8S(Instrs\Numeric\I64Extend8S $instr): void
+    {
+        $c1 = $this->stack->popInt();
+        $c2 = $c1 & 0xFF;
+        $result = unpack('c', pack('C', $c2));
+        assert($result !== false);
+        $this->stack->pushValue($result[1]);
+    }
+
+    private function execInstrNumericI64ExtendI32S(Instrs\Numeric\I64ExtendI32S $instr): void
+    {
+        $c1 = $this->stack->popInt();
+        $this->stack->pushValue($c1);
+    }
+
+    private function execInstrNumericI64ExtendI32U(Instrs\Numeric\I64ExtendI32U $instr): void
+    {
+        $c1 = NumericOps::convertS32ToU32($this->stack->popInt());
+        $c2 = $c1 & 0xFFFFFFFF;
+        $this->stack->pushValue($c2);
+    }
+
+    private function execInstrNumericI64GeS(Instrs\Numeric\I64GeS $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushBool($c1 >= $c2);
+    }
+
+    private function execInstrNumericI64GeU(Instrs\Numeric\I64GeU $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c2Packed = pack('J', $c2);
+        $c1 = $this->stack->popInt();
+        $c1Packed = pack('J', $c1);
+        $this->stack->pushBool($c1Packed >= $c2Packed);
+    }
+
+    private function execInstrNumericI64GtS(Instrs\Numeric\I64GtS $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushBool($c1 > $c2);
+    }
+
+    private function execInstrNumericI64GtU(Instrs\Numeric\I64GtU $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c2Packed = pack('J', $c2);
+        $c1 = $this->stack->popInt();
+        $c1Packed = pack('J', $c1);
+        $this->stack->pushBool($c1Packed > $c2Packed);
+    }
+
+    private function execInstrNumericI64LeS(Instrs\Numeric\I64LeS $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushBool($c1 <= $c2);
+    }
+
+    private function execInstrNumericI64LeU(Instrs\Numeric\I64LeU $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c2Packed = pack('J', $c2);
+        $c1 = $this->stack->popInt();
+        $c1Packed = pack('J', $c1);
+        $this->stack->pushBool($c1Packed <= $c2Packed);
+    }
+
+    private function execInstrNumericI64LtS(Instrs\Numeric\I64LtS $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushBool($c1 < $c2);
+    }
+
+    private function execInstrNumericI64LtU(Instrs\Numeric\I64LtU $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c2Packed = pack('J', $c2);
+        $c1 = $this->stack->popInt();
+        $c1Packed = pack('J', $c1);
+        $this->stack->pushBool($c1Packed < $c2Packed);
+    }
+
+    private function execInstrNumericI64Mul(Instrs\Numeric\I64Mul $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $result = NumericOps::bigIntToPhpInt(bcmul((string)$c1, (string)$c2));
+        $this->stack->pushValue($result);
+    }
+
+    private function execInstrNumericI64Ne(Instrs\Numeric\I64Ne $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushBool($c1 !== $c2);
+    }
+
+    private function execInstrNumericI64Or(Instrs\Numeric\I64Or $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushValue($c1 | $c2);
+    }
+
+    private function execInstrNumericI64Popcnt(Instrs\Numeric\I64Popcnt $instr): void
+    {
+        $i = $this->stack->popInt();
+        $popcnt = 0;
+        for ($j = 0; $j < 64; $j++) {
+            if (($i & (1 << $j)) !== 0) {
+                $popcnt++;
+            }
+        }
+        $this->stack->pushValue($popcnt);
+    }
+
+    private function execInstrNumericI64ReinterpretF32(Instrs\Numeric\I64ReinterpretF32 $instr): void
+    {
+        $v = $this->stack->popFloat();
+        $this->stack->pushValue(NumericOps::reinterpretF32AsI64($v));
+    }
+
+    private function execInstrNumericI64ReinterpretF64(Instrs\Numeric\I64ReinterpretF64 $instr): void
+    {
+        $v = $this->stack->popFloat();
+        $this->stack->pushValue(NumericOps::reinterpretF64AsI64($v));
+    }
+
+    private function execInstrNumericI64RemS(Instrs\Numeric\I64RemS $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        if ($c2 === 0) {
+            throw new TrapException("i64.rem_s: divide by zero", trapKind: TrapKind::DivideByZero);
+        }
+        $this->stack->pushValue($c1 % $c2);
+    }
+
+    private function execInstrNumericI64RemU(Instrs\Numeric\I64RemU $instr): void
+    {
+        $c2 = NumericOps::convertS64ToBigUInt($this->stack->popInt());
+        $c1 = NumericOps::convertS64ToBigUInt($this->stack->popInt());
+        if ($c2 === '0') {
+            throw new TrapException("i64.rem_u: divide by zero", trapKind: TrapKind::DivideByZero);
+        }
+        $this->stack->pushValue(NumericOps::bigIntToPhpInt(bcmod($c1, $c2, 0)));
+    }
+
+    private function execInstrNumericI64RotL(Instrs\Numeric\I64RotL $instr): void
+    {
+        $i2 = NumericOps::convertS64ToBigUInt($this->stack->popInt());
+        $k = (int)bcmod($i2, '64');
+        $i1 = $this->stack->popInt();
+        $left = $i1 << $k;
+        $right = $i1;
+        for ($i = 0; $i < 64 - $k; $i++) {
+            $right = ($right >> 1) & 0x7FFFFFFFFFFFFFFF;
+        }
+        $this->stack->pushValue($left | $right);
+    }
+
+    private function execInstrNumericI64RotR(Instrs\Numeric\I64RotR $instr): void
+    {
+        $i2 = NumericOps::convertS64ToBigUInt($this->stack->popInt());
+        $k = (int)bcmod($i2, '64');
+        $i1 = $this->stack->popInt();
+        $left = $i1;
+        for ($i = 0; $i < $k; $i++) {
+            $left = ($left >> 1) & 0x7FFFFFFFFFFFFFFF;
+        }
+        $right = $i1 << (64 - $k);
+        $this->stack->pushValue($left | $right);
+    }
+
+    private function execInstrNumericI64Shl(Instrs\Numeric\I64Shl $instr): void
+    {
+        $c2 = NumericOps::convertS64ToBigUInt($this->stack->popInt());
+        $k = (int)bcmod($c2, '64');
+        $c1 = $this->stack->popInt();
+        $this->stack->pushValue($c1 << $k);
+    }
+
+    private function execInstrNumericI64ShrS(Instrs\Numeric\I64ShrS $instr): void
+    {
+        $c2 = NumericOps::convertS64ToBigUInt($this->stack->popInt());
+        $k = (int)bcmod($c2, '64');
+        $c1 = $this->stack->popInt();
+        $this->stack->pushValue($c1 >> $k);
+    }
+
+    private function execInstrNumericI64ShrU(Instrs\Numeric\I64ShrU $instr): void
+    {
+        $c2 = NumericOps::convertS64ToBigUInt($this->stack->popInt());
+        $k = (int)bcmod($c2, '64');
+        if ($k === 0) {
+            return;
+        }
+        // Perform shr_u based on string manipulation because PHP does not
+        // support shr_u operation.
+        $c1 = $this->stack->popInt();
+        $this->stack->pushValue(bindec(substr(decbin($c1), 0, -$k)));
+    }
+
+    private function execInstrNumericI64Sub(Instrs\Numeric\I64Sub $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $result = NumericOps::bigIntToPhpInt(bcsub((string)$c1, (string)$c2));
+        $this->stack->pushValue($result);
+    }
+
+    private function execInstrNumericI64TruncF32S(Instrs\Numeric\I64TruncF32S $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if (is_nan($v)) {
+            throw new TrapException($instr::opName() . ": invalid conversion ($v)", trapKind: TrapKind::InvalidConversionToInteger);
+        }
+        if (is_infinite($v)) {
+            throw new TrapException($instr::opName() . ": overflow ($v)", trapKind: TrapKind::IntegerOverflow);
+        }
+        if ($v <= -9223372036854775809.0 || 9223372036854775808.0 <= $v) {
+            throw new TrapException($instr::opName() . ": overflow ($v)", trapKind: TrapKind::IntegerOverflow);
+        }
+        $this->stack->pushValue((int) $v);
+    }
+
+    private function execInstrNumericI64TruncF32U(Instrs\Numeric\I64TruncF32U $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if (is_nan($v)) {
+            throw new TrapException($instr::opName() . ": invalid conversion", trapKind: TrapKind::InvalidConversionToInteger);
+        }
+        if (is_infinite($v)) {
+            throw new TrapException($instr::opName() . ": overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        if ($v <= -1.0 || 18446744073709551616.0 <= $v) {
+            throw new TrapException($instr::opName() . ": overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        $this->stack->pushValue((int) $v);
+    }
+
+    private function execInstrNumericI64TruncF64S(Instrs\Numeric\I64TruncF64S $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if (is_nan($v)) {
+            throw new TrapException($instr::opName() . ": invalid conversion", trapKind: TrapKind::InvalidConversionToInteger);
+        }
+        if (is_infinite($v)) {
+            throw new TrapException($instr::opName() . ": overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        if ($v <= -9223372036854775809.0 || 9223372036854775808.0 <= $v) {
+            throw new TrapException($instr::opName() . ": overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        $this->stack->pushValue((int) $v);
+    }
+
+    private function execInstrNumericI64TruncF64U(Instrs\Numeric\I64TruncF64U $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if (is_nan($v)) {
+            throw new TrapException($instr::opName() . ": invalid conversion", trapKind: TrapKind::InvalidConversionToInteger);
+        }
+        if (is_infinite($v)) {
+            throw new TrapException($instr::opName() . ": overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        if ($v <= -1.0 || 18446744073709551616.0 <= $v) {
+            throw new TrapException($instr::opName() . ": overflow", trapKind: TrapKind::IntegerOverflow);
+        }
+        $this->stack->pushValue((int) $v);
+    }
+
+    private function execInstrNumericI64TruncSatF32S(Instrs\Numeric\I64TruncSatF32S $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if ($v < -9223372036854775808.0) {
+            $this->stack->pushValue(-9223372036854775808);
+        } elseif ($v > 9223372036854775807.0) {
+            $this->stack->pushValue(9223372036854775807);
+        } else {
+            $this->stack->pushValue((int) $v);
+        }
+    }
+
+    private function execInstrNumericI64TruncSatF32U(Instrs\Numeric\I64TruncSatF32U $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if ($v < 0.0) {
+            $this->stack->pushValue(0);
+        } elseif ($v > 18446744073709551615.0) {
+            $this->stack->pushValue(18446744073709551615);
+        } else {
+            $this->stack->pushValue((int) $v);
+        }
+    }
+
+    private function execInstrNumericI64TruncSatF64S(Instrs\Numeric\I64TruncSatF64S $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if ($v < -9223372036854775808.0) {
+            $this->stack->pushValue(-9223372036854775808);
+        } elseif ($v > 9223372036854775807.0) {
+            $this->stack->pushValue(9223372036854775807);
+        } else {
+            $this->stack->pushValue((int) $v);
+        }
+    }
+
+    private function execInstrNumericI64TruncSatF64U(Instrs\Numeric\I64TruncSatF64U $instr): void
+    {
+        $v = $this->stack->popFloat();
+        if ($v < 0.0) {
+            $this->stack->pushValue(0);
+        } elseif ($v > 18446744073709551615.0) {
+            $this->stack->pushValue(18446744073709551615);
+        } else {
+            $this->stack->pushValue((int) $v);
+        }
+    }
+
+    private function execInstrNumericI64Xor(Instrs\Numeric\I64Xor $instr): void
+    {
+        $c2 = $this->stack->popInt();
+        $c1 = $this->stack->popInt();
+        $this->stack->pushValue($c1 ^ $c2);
+    }
+
+    private function execInstrReferenceRefFunc(Instrs\Reference\RefFunc $instr): void
+    {
+        $x = $instr->func;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->funcAddrs[$x];
+        $this->stack->pushRefFunc($a);
+    }
+
+    private function execInstrReferenceRefIsNull(Instrs\Reference\RefIsNull $instr): void
+    {
+        $val = $this->stack->popRef();
+        $this->stack->pushBool($val instanceof Refs\RefNull);
+    }
+
+    private function execInstrReferenceRefNull(Instrs\Reference\RefNull $instr): void
+    {
+        $t = $instr->type;
+        $this->stack->pushRefNull($t);
+    }
+
+    private function execInstrParametricDrop(Instrs\Parametric\Drop $instr): void
+    {
+        $this->stack->popValue();
+    }
+
+    private function execInstrParametricSelect(Instrs\Parametric\Select $instr): void
+    {
+        $c = $this->stack->popInt();
+        $val2 = $this->stack->popValue();
+        $val1 = $this->stack->popValue();
+        if ($c !== 0) {
+            $this->stack->pushValue($val1);
+        } else {
+            $this->stack->pushValue($val2);
+        }
+    }
+
+    private function execInstrVariableGlobalGet(Instrs\Variable\GlobalGet $instr): void
+    {
+        $x = $instr->var;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->globalAddrs[$x];
+        $glob = $this->store->globals[$a];
+        $val = $glob->value;
+        $this->stack->pushValue($val);
+    }
+
+    private function execInstrVariableGlobalSet(Instrs\Variable\GlobalSet $instr): void
+    {
+        $x = $instr->var;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->globalAddrs[$x];
+        $glob = $this->store->globals[$a];
+        $val = $this->stack->popValue();
+        $glob->value = $val;
+    }
+
+    private function execInstrVariableLocalGet(Instrs\Variable\LocalGet $instr): void
+    {
+        $x = $instr->var;
+        $f = $this->stack->currentFrame();
+        $val = $f->locals[$x] ?? null;
+        if ($val === null) {
+            throw new RuntimeException("local.get: local $x not found in [$f->debugName]");
+        }
+        $this->stack->pushValue($val);
+    }
+
+    private function execInstrVariableLocalSet(Instrs\Variable\LocalSet $instr): void
+    {
+        $x = $instr->var;
+        $f = $this->stack->currentFrame();
+        $val = $this->stack->popValue();
+        // @phpstan-ignore-next-line
+        $f->locals[$x] = $val;
+    }
+
+    private function execInstrVariableLocalTee(Instrs\Variable\LocalTee $instr): void
+    {
+        $x = $instr->var;
+        $f = $this->stack->currentFrame();
+        $val = $this->stack->popValue();
+        // @phpstan-ignore-next-line
+        $f->locals[$x] = $val;
+        $this->stack->pushValue($val);
+    }
+
+    private function execInstrTableElemDrop(Instrs\Table\ElemDrop $instr): void
+    {
+        $x = $instr->elem;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->elemAddrs[$x];
+        $elem = $this->store->elems[$a];
+        // @phpstan-ignore-next-line
+        $this->store->elems[$a] = new ElemInst($elem->type, []);
+    }
+
+    private function execInstrTableTableCopy(Instrs\Table\TableCopy $instr): void
+    {
+        $x = $instr->to;
+        $y = $instr->from;
+        $f = $this->stack->currentFrame();
+        $taX = $f->module->tableAddrs[$x];
+        $tabX = $this->store->tables[$taX];
+        $taY = $f->module->tableAddrs[$y];
+        $tabY = $this->store->tables[$taY];
+        $n = NumericOps::convertS32ToU32($this->stack->popInt());
+        $s = NumericOps::convertS32ToU32($this->stack->popInt());
+        $d = NumericOps::convertS32ToU32($this->stack->popInt());
+        if (count($tabX->elem) < $d + $n || count($tabY->elem) < $s + $n) {
+            throw new TrapException("table.copy: out of bounds", trapKind: TrapKind::OutOfBoundsTableAccess);
+        }
+        if ($n === 0 || ($x === $y && $d === $s)) {
+            return;
+        }
+        for ($i = 0; $i < $n; $i++) {
+            $s_ = ($d < $s) ? ($s + $i) : ($s + $n - 1 - $i);
+            $d_ = ($d < $s) ? ($d + $i) : ($d + $n - 1 - $i);
+            // @phpstan-ignore-next-line
+            $tabX->elem[$d_] = $tabY->elem[$s_];
+        }
+    }
+
+    private function execInstrTableTableFill(Instrs\Table\TableFill $instr): void
+    {
+        $x = $instr->table;
+        $f = $this->stack->currentFrame();
+        $ta = $f->module->tableAddrs[$x];
+        $tab = $this->store->tables[$ta];
+        $n = NumericOps::convertS32ToU32($this->stack->popInt());
+        $val = $this->stack->popRef();
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        if (count($tab->elem) < $i + $n) {
+            throw new TrapException("table.fill: out of bounds", trapKind: TrapKind::OutOfBoundsTableAccess);
+        }
+        for ($k = 0; $k < $n; $k++) {
+            // @phpstan-ignore-next-line
+            $tab->elem[$i + $k] = $val;
+        }
+    }
+
+    private function execInstrTableTableGet(Instrs\Table\TableGet $instr): void
+    {
+        $x = $instr->table;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->tableAddrs[$x];
+        $tab = $this->store->tables[$a];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        if (count($tab->elem) <= $i) {
+            throw new TrapException("table.get: out of bounds", trapKind: TrapKind::OutOfBoundsTableAccess);
+        }
+        $val = $tab->elem[$i];
+        $this->stack->pushValue($val);
+    }
+
+    private function execInstrTableTableGrow(Instrs\Table\TableGrow $instr): void
+    {
+        $x = $instr->table;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->tableAddrs[$x];
+        $tab = $this->store->tables[$a];
+        $sz = count($tab->elem);
+        $n = NumericOps::convertS32ToU32($this->stack->popInt());
+        $val = $this->stack->popRef();
+
+        $len = $sz + $n;
+        if ((1 << 32) <= $len) {
+            $this->stack->pushValue(-1);
+            return;
+        }
+
+        $limits = $tab->type->limits;
+        $limits_ = new Limits($len, $limits->max);
+        if (!$limits_->isValid()) {
+            $this->stack->pushValue(-1);
+            return;
+        }
+
+        for ($i = 0; $i < $n; $i++) {
+            $tab->elem[] = $val;
+        }
+        $tab->type = new TableType($limits_, $tab->type->refType);
+
+        $this->stack->pushValue($sz);
+    }
+
+    private function execInstrTableTableInit(Instrs\Table\TableInit $instr): void
+    {
+        $x = $instr->to;
+        $y = $instr->from;
+        $f = $this->stack->currentFrame();
+        $ta = $f->module->tableAddrs[$x];
+        $tab = $this->store->tables[$ta];
+        $ea = $f->module->elemAddrs[$y];
+        $elem = $this->store->elems[$ea];
+        $n = NumericOps::convertS32ToU32($this->stack->popInt());
+        $s = NumericOps::convertS32ToU32($this->stack->popInt());
+        $d = NumericOps::convertS32ToU32($this->stack->popInt());
+        if (count($elem->elem) < $s + $n) {
+            throw new TrapException("table.init: out of bounds", trapKind: TrapKind::OutOfBoundsTableAccess);
+        }
+        if (count($tab->elem) < $d + $n) {
+            throw new TrapException("table.init: out of bounds", trapKind: TrapKind::OutOfBoundsTableAccess);
+        }
+        for ($i = 0; $i < $n; $i++) {
+            // @phpstan-ignore-next-line
+            $tab->elem[$d + $i] = $elem->elem[$s + $i];
+        }
+    }
+
+    private function execInstrTableTableSet(Instrs\Table\TableSet $instr): void
+    {
+        $x = $instr->table;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->tableAddrs[$x];
+        $tab = $this->store->tables[$a];
+        $val = $this->stack->popRef();
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        if (count($tab->elem) <= $i) {
+            throw new TrapException("table.set: out of bounds", trapKind: TrapKind::OutOfBoundsTableAccess);
+        }
+        // @phpstan-ignore-next-line
+        $tab->elem[$i] = $val;
+    }
+
+    private function execInstrTableTableSize(Instrs\Table\TableSize $instr): void
+    {
+        $x = $instr->table;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->tableAddrs[$x];
+        $tab = $this->store->tables[$a];
+        $sz = count($tab->elem);
+        $this->stack->pushValue($sz);
+    }
+
+    private function execInstrMemoryDataDrop(Instrs\Memory\DataDrop $instr): void
+    {
+        $x = $instr->data;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->dataAddrs[$x];
+        // @phpstan-ignore-next-line
+        $this->store->datas[$a] = new DataInst([]);
+    }
+
+    private function execInstrMemoryF32Load(Instrs\Memory\F32Load $instr): void
+    {
+        $this->doLoadF32($instr->offset, $instr::opName());
+    }
+
+    private function execInstrMemoryF32Store(Instrs\Memory\F32Store $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $c = $this->stack->popFloat();
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $ok = $mem->storeF32($ea, $c);
+        if (!$ok) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+    }
+
+    private function execInstrMemoryF64Load(Instrs\Memory\F64Load $instr): void
+    {
+        $this->doLoadF64($instr->offset, $instr::opName());
+    }
+
+    private function execInstrMemoryF64Store(Instrs\Memory\F64Store $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $c = $this->stack->popFloat();
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $ok = $mem->storeF64($ea, $c);
+        if (!$ok) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+    }
+
+    private function execInstrMemoryI32Load(Instrs\Memory\I32Load $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $c = $mem->loadI32_s32($ea);
+        if ($c === null) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $this->stack->pushValue($c);
+    }
+
+    private function execInstrMemoryI32Load16S(Instrs\Memory\I32Load16S $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $c = $mem->loadI32_s16($ea);
+        if ($c === null) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $this->stack->pushValue($c);
+    }
+
+    private function execInstrMemoryI32Load16U(Instrs\Memory\I32Load16U $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $c = $mem->loadI32_u16($ea);
+        if ($c === null) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $this->stack->pushValue($c);
+    }
+
+    private function execInstrMemoryI32Load8S(Instrs\Memory\I32Load8S $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $c = $mem->loadI32_s8($ea);
+        if ($c === null) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $this->stack->pushValue($c);
+    }
+
+    private function execInstrMemoryI32Load8U(Instrs\Memory\I32Load8U $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $c = $mem->loadI32_u8($ea);
+        if ($c === null) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $this->stack->pushValue($c);
+    }
+
+    private function execInstrMemoryI32Store(Instrs\Memory\I32Store $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $c = $this->stack->popInt();
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $ok = $mem->storeI32_s32($ea, $c);
+        if (!$ok) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+    }
+
+    private function execInstrMemoryI32Store16(Instrs\Memory\I32Store16 $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $c = $this->stack->popInt();
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $ok = $mem->storeI32_s16($ea, $c);
+        if (!$ok) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+    }
+
+    private function execInstrMemoryI32Store8(Instrs\Memory\I32Store8 $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $c = $this->stack->popInt();
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $ok = $mem->storeI32_s8($ea, $c);
+        if (!$ok) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+    }
+
+    private function execInstrMemoryI64Load(Instrs\Memory\I64Load $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $c = $mem->loadI64_s64($ea);
+        if ($c === null) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $this->stack->pushValue($c);
+    }
+
+    private function execInstrMemoryI64Load16S(Instrs\Memory\I64Load16S $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $c = $mem->loadI64_s16($ea);
+        if ($c === null) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $this->stack->pushValue($c);
+    }
+
+    private function execInstrMemoryI64Load16U(Instrs\Memory\I64Load16U $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $c = $mem->loadI64_u16($ea);
+        if ($c === null) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $this->stack->pushValue($c);
+    }
+
+    private function execInstrMemoryI64Load32S(Instrs\Memory\I64Load32S $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $c = $mem->loadI64_s32($ea);
+        if ($c === null) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $this->stack->pushValue($c);
+    }
+
+    private function execInstrMemoryI64Load32U(Instrs\Memory\I64Load32U $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $c = $mem->loadI64_u32($ea);
+        if ($c === null) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $this->stack->pushValue($c);
+    }
+
+    private function execInstrMemoryI64Load8S(Instrs\Memory\I64Load8S $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $c = $mem->loadI64_s8($ea);
+        if ($c === null) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $this->stack->pushValue($c);
+    }
+
+    private function execInstrMemoryI64Load8U(Instrs\Memory\I64Load8U $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $c = $mem->loadI64_u8($ea);
+        if ($c === null) {
+            throw new TrapException($instr::opName() . ": out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $this->stack->pushValue($c);
+    }
+
+    private function execInstrMemoryI64Store(Instrs\Memory\I64Store $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $c = $this->stack->popInt();
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $ok = $mem->storeI64_s64($ea, $c);
+        if (!$ok) {
+            throw new TrapException($instr::opName() . ": out of bounds: $ea >= " . $mem->size(), trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+    }
+
+    private function execInstrMemoryI64Store16(Instrs\Memory\I64Store16 $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $c = $this->stack->popInt();
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $ok = $mem->storeI64_s16($ea, $c);
+        if (!$ok) {
+            throw new TrapException($instr::opName() . ": out of bounds: $ea >= " . $mem->size(), trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+    }
+
+    private function execInstrMemoryI64Store32(Instrs\Memory\I64Store32 $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $c = $this->stack->popInt();
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $ok = $mem->storeI64_s32($ea, $c);
+        if (!$ok) {
+            throw new TrapException($instr::opName() . ": out of bounds: $ea >= " . $mem->size(), trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+    }
+
+    private function execInstrMemoryI64Store8(Instrs\Memory\I64Store8 $instr): void
+    {
+        $offset = $instr->offset;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $c = $this->stack->popInt();
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $ok = $mem->storeI64_s8($ea, $c);
+        if (!$ok) {
+            throw new TrapException($instr::opName() . ": out of bounds: $ea >= " . $mem->size(), trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+    }
+
+    private function execInstrMemoryMemoryCopy(Instrs\Memory\MemoryCopy $instr): void
+    {
+        $f = $this->stack->currentFrame();
+        $ma = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$ma];
+        $n = NumericOps::convertS32ToU32($this->stack->popInt());
+        $s = NumericOps::convertS32ToU32($this->stack->popInt());
+        $d = NumericOps::convertS32ToU32($this->stack->popInt());
+        if ($mem->size() < $s + $n || $mem->size() < $d + $n) {
+            throw new TrapException("memory.copy: out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $mem->memcpy($d, $s, $n);
+    }
+
+    private function execInstrMemoryMemoryFill(Instrs\Memory\MemoryFill $instr): void
+    {
+        $f = $this->stack->currentFrame();
+        $ma = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$ma];
+        $n = NumericOps::convertS32ToU32($this->stack->popInt());
+        $val = $this->stack->popInt();
+        $d = NumericOps::convertS32ToU32($this->stack->popInt());
+        if ($mem->size() < $d + $n) {
+            throw new TrapException("memory.fill: out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $mem->memset($d, $val, $n);
+    }
+
+    private function execInstrMemoryMemoryGrow(Instrs\Memory\MemoryGrow $instr): void
+    {
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $n = NumericOps::convertS32ToU32($this->stack->popInt());
+        $result = $mem->grow($n);
+        $this->stack->pushValue($result);
+    }
+
+    private function execInstrMemoryMemoryInit(Instrs\Memory\MemoryInit $instr): void
+    {
+        $x = $instr->data;
+        $f = $this->stack->currentFrame();
+        $ma = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$ma];
+        $da = $f->module->dataAddrs[$x];
+        $data = $this->store->datas[$da];
+        $n = NumericOps::convertS32ToU32($this->stack->popInt());
+        $s = NumericOps::convertS32ToU32($this->stack->popInt());
+        $d = NumericOps::convertS32ToU32($this->stack->popInt());
+        if (count($data->data) < $s + $n) {
+            throw new TrapException("memory.init: out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        if ($mem->size() < $d + $n) {
+            throw new TrapException("memory.init: out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $mem->copyData($data->data, $s, $d, $n);
+    }
+
+    private function execInstrMemoryMemorySize(Instrs\Memory\MemorySize $instr): void
+    {
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $szInByte = $mem->size();
+        assert(is_int($szInByte / (64 * 1024)));
+        $sz = $szInByte / (64 * 1024);
+        $this->stack->pushValue($sz);
+    }
+
+    private function execInstrControlBlock(Instrs\Control\Block $instr): ?int
+    {
+        $blockType = $instr->type;
+        $instrs = $instr->body;
+        $f = $this->stack->currentFrame();
+        $bt = self::expandBlockType($blockType, $f->module);
+        $params = array_reverse($this->stack->popNValues(count($bt->params->types)));
+        $n = count($bt->results->types);
+        $l = new Label($n);
+        $result = $this->execInstrs($instrs, $l, $params);
+        if ($result === null) {
+            // Do nothing.
+        } elseif ($result === -1) {
+            return -1;
+        } elseif ($result === 0) {
+            $this->deactivateLabel($n);
+        } else {
+            $this->deactivateLabel(null);
+            return $result - 1;
+        }
+        return null;
+    }
+
+    private function execInstrControlBr(Instrs\Control\Br $instr): int
+    {
+        return $instr->label;
+    }
+
+    private function execInstrControlBrIf(Instrs\Control\BrIf $instr): ?int
+    {
+        $l = $instr->label;
+        $c = $this->stack->popInt();
+        if ($c !== 0) {
+            return $l;
+        } else {
+            return null;
+        }
+    }
+
+    private function execInstrControlBrTable(Instrs\Control\BrTable $instr): int
+    {
+        $ls = $instr->labelTable;
+        $ln = $instr->defaultLabel;
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        if ($i < count($ls)) {
+            return $ls[$i];
+        } else {
+            return $ln;
+        }
+    }
+
+    private function execInstrControlCall(Instrs\Control\Call $instr): void
+    {
+        $x = $instr->func;
+        $f = $this->stack->currentFrame();
+        $a = $f->module->funcAddrs[$x];
+        $this->doInvokeFunc($a);
+    }
+
+    private function execInstrControlCallIndirect(Instrs\Control\CallIndirect $instr): void
+    {
+        $x = $instr->funcTable;
+        $y = $instr->type;
+        $f = $this->stack->currentFrame();
+        $ta = $f->module->tableAddrs[$x];
+        $tab = $this->store->tables[$ta];
+        $ftExpect = $f->module->types[$y];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        if (count($tab->elem) <= $i) {
+            throw new TrapException("call_indirect: out of bounds", trapKind: TrapKind::UndefinedElement);
+        }
+        $r = $tab->elem[$i];
+        if ($r instanceof Refs\RefNull) {
+            throw new TrapException("call_indirect: ref.null", trapKind: TrapKind::UninitializedElement);
+        }
+        assert($r instanceof Refs\RefFunc);
+        $a = $r->addr;
+        $fn = $this->store->funcs[$a];
+        assert($fn instanceof FuncInsts\Wasm || $fn instanceof FuncInsts\Host);
+        $ftActual = $fn->type;
+        if (!$ftExpect->equals($ftActual)) {
+            throw new TrapException("call_indirect: type mismatch", trapKind: TrapKind::IndirectCallTypeMismatch);
+        }
+        $this->doInvokeFunc($a);
+    }
+
+    private function execInstrControlElse_(Instrs\Control\Else_ $instr): void
+    {
+        // Do nothing.
+    }
+
+    private function execInstrControlEnd(Instrs\Control\End $instr): void
+    {
+        // Do nothing.
+    }
+
+    private function execInstrControlIf_(Instrs\Control\If_ $instr): ?int
+    {
+        $blockType = $instr->type;
+        $instrs1 = $instr->thenBody;
+        $instrs2 = $instr->elseBody;
+        $c = $this->stack->popInt();
+        if ($c !== 0) {
+            return $this->execInstr(Instr::Block($blockType, $instrs1));
+        } else {
+            return $this->execInstr(Instr::Block($blockType, $instrs2));
+        }
+    }
+
+    private function execInstrControlLoop(Instrs\Control\Loop $instr): ?int
+    {
+        $blockType = $instr->type;
+        $instrs = $instr->body;
+        $f = $this->stack->currentFrame();
+        $bt = self::expandBlockType($blockType, $f->module);
+        $m = count($bt->params->types);
+        $l = new Label($m);
+        while (true) {
+            $params = array_reverse($this->stack->popNValues($m));
+            $result = $this->execInstrs($instrs, $l, $params);
+            if ($result === null) {
+                return null;
+            } elseif ($result === -1) {
+                return -1;
+            } elseif ($result === 0) {
+                $this->deactivateLabel($m);
+                continue;
+            } else {
+                $this->deactivateLabel(null);
+                return $result - 1;
+            }
+        }
+    }
+
+    private function execInstrControlNop(Instrs\Control\Nop $instr): void
+    {
+        // Do nothing.
+    }
+
+    private function execInstrControlReturn_(Instrs\Control\Return_ $instr): int
+    {
+        return -1;
+    }
+
+    private function execInstrControlUnreachable(Instrs\Control\Unreachable $instr): void
+    {
+        throw new TrapException("unreachable", trapKind: TrapKind::Unreachable);
+    }
+
+    private function doLoadF32(int $offset, string $instrOpName): void
+    {
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $c = $mem->loadF32($ea);
+        if ($c === null) {
+            throw new TrapException("$instrOpName: out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $this->stack->pushValue($c);
+    }
+
+    private function doLoadF64(int $offset, string $instrOpName): void
+    {
+        $f = $this->stack->currentFrame();
+        $a = $f->module->memAddrs[0];
+        $mem = $this->store->mems[$a];
+        $i = NumericOps::convertS32ToU32($this->stack->popInt());
+        $ea = $i + $offset;
+        $c = $mem->loadF64($ea);
+        if ($c === null) {
+            throw new TrapException("$instrOpName: out of bounds", trapKind: TrapKind::OutOfBoundsMemoryAccess);
+        }
+        $this->stack->pushValue($c);
+    }
+
+    private static function defaultValueFromValType(ValType $type): int|float|Ref
+    {
+        return match ($type::class) {
+            ValTypes\NumType::class => match ($type->inner) {
+                NumType::I32 => 0,
+                NumType::I64 => 0,
+                NumType::F32 => 0.0,
+                NumType::F64 => 0.0,
+            },
+            ValTypes\RefType::class => Ref::RefNull($type->inner),
+            default => throw new RuntimeException("unreachable"),
+        };
+    }
+
+    private static function expandBlockType(BlockType $bt, ModuleInst $module): FuncType
+    {
+        if ($bt instanceof BlockTypes\TypeIdx) {
+            return $module->types[$bt->inner];
+        } elseif ($bt instanceof BlockTypes\ValType) {
+            $t = $bt->inner;
+            return new FuncType(
+                new ResultType([]),
+                new ResultType($t === null ? [] : [$t]),
+            );
+        } else {
+            throw new RuntimeException("expand(): invalid blocktype");
+        }
+    }
+}
diff --git a/src/WebAssembly/Execution/Stack.php b/src/WebAssembly/Execution/Stack.php
new file mode 100644
index 0000000..4181dcd
--- /dev/null
+++ b/src/WebAssembly/Execution/Stack.php
@@ -0,0 +1,212 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\RefType;
+use function assert;
+use function count;
+use function is_float;
+use function is_int;
+use function is_null;
+
+final class Stack
+{
+    /**
+     * @var list<Frame>
+     */
+    private array $frames = [];
+
+    private ?Frame $currentFrame = null;
+
+    /**
+     * @var list<int|float|Ref|Frame|Label>
+     */
+    private array $entries;
+
+    public function __construct()
+    {
+    }
+
+    public function pushFrame(Frame $frame): void
+    {
+        if ($this->getCallStackLimit() <= count($this->frames)) {
+            throw new StackOverflowException();
+        }
+        $this->push($frame);
+        $this->frames[] = $frame;
+        $this->currentFrame = $frame;
+    }
+
+    public function pushLabel(Label $label): void
+    {
+        $this->push($label);
+    }
+
+    public function pushValue(int|float|Ref $val): void
+    {
+        $this->push($val);
+    }
+
+    public function pushBool(bool $value): void
+    {
+        $this->pushValue((int)$value);
+    }
+
+    public function pushRefNull(RefType $type): void
+    {
+        $this->pushValue(Ref::RefNull($type));
+    }
+
+    public function pushRefFunc(int $addr): void
+    {
+        $this->pushValue(Ref::RefFunc($addr));
+    }
+
+    public function pushRefExtern(int $addr): void
+    {
+        $this->pushValue(Ref::RefExtern($addr));
+    }
+
+    public function clear(): void
+    {
+        $this->frames = [];
+        $this->currentFrame = null;
+        $this->entries = [];
+    }
+
+    public function popFrame(): Frame
+    {
+        $result = $this->pop();
+        assert($result instanceof Frame);
+        array_pop($this->frames);
+        if (count($this->frames) === 0) {
+            $this->currentFrame = null;
+        } else {
+            $this->currentFrame = end($this->frames);
+        }
+        return $result;
+    }
+
+    public function popValue(): int|float|Ref
+    {
+        $result = $this->pop();
+        assert(
+            is_int($result) || is_float($result) || $result instanceof Ref,
+            'Expected a value on the stack, but got ' . print_r($result, true),
+        );
+        return $result;
+    }
+
+    /**
+     * @return list<int|float|Ref>
+     */
+    public function popNValues(int $n): array
+    {
+        $results = [];
+        for ($i = 0; $i < $n; $i++) {
+            $results[] = $this->popValue();
+        }
+        return $results;
+    }
+
+    public function popInt(): int
+    {
+        $v = $this->popValue();
+        assert(is_int($v), "Expected an int on top of the stack, but got " . self::getValueTypeName($v));
+        return $v;
+    }
+
+    /**
+     * @return F32
+     */
+    public function popFloat(): float
+    {
+        $v = $this->popValue();
+        assert(is_float($v), "Expected a float on top of the stack, but got " . self::getValueTypeName($v));
+        return $v;
+    }
+
+    public function popRef(): Ref
+    {
+        $v = $this->popValue();
+        assert($v instanceof Ref, "Expected a Ref on top of the stack, but got " . self::getValueTypeName($v));
+        return $v;
+    }
+
+    /**
+     * @return list<int|float|Ref>
+     */
+    public function popValuesToLabel(): array
+    {
+        $results = [];
+        while (!$this->isEmpty()) {
+            $top = $this->pop();
+            if ($top instanceof Label) {
+                break;
+            } else {
+                assert(is_int($top) || is_float($top) || $top instanceof Ref);
+                $results[] = $top;
+            }
+        }
+        return $results;
+    }
+
+    public function popEntriesToCurrentFrame(): void
+    {
+        while (!$this->isEmpty() && !$this->top() instanceof Frame) {
+            $this->pop();
+        }
+        $this->popFrame();
+    }
+
+    public function top(): int|float|Ref|Frame|Label|null
+    {
+        $n = array_key_last($this->entries);
+        return $n === null ? null : $this->entries[$n];
+    }
+
+    public function count(): int
+    {
+        return count($this->entries);
+    }
+
+    public function isEmpty(): bool
+    {
+        return $this->count() === 0;
+    }
+
+    public function currentFrame(): Frame
+    {
+        assert($this->currentFrame !== null);
+        return $this->currentFrame;
+    }
+
+    public function getCallStackLimit(): int
+    {
+        return 1024;
+    }
+
+    private function push(int|float|Ref|Frame|Label $entry): void
+    {
+        $this->entries[] = $entry;
+    }
+
+    private function pop(): int|float|Ref|Frame|Label|null
+    {
+        return array_pop($this->entries);
+    }
+
+    private static function getValueTypeName(int|float|Ref|Frame|Label|null $value): string
+    {
+        return match (true) {
+            is_null($value) => 'null',
+            is_int($value) => 'int',
+            is_float($value) => 'float',
+            $value instanceof Ref => 'Ref',
+            $value instanceof Frame => 'Frame',
+            $value instanceof Label => 'Label',
+        };
+    }
+}
diff --git a/src/WebAssembly/Execution/StackOverflowException.php b/src/WebAssembly/Execution/StackOverflowException.php
new file mode 100644
index 0000000..c5ff3a4
--- /dev/null
+++ b/src/WebAssembly/Execution/StackOverflowException.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+use RuntimeException;
+use Throwable;
+
+final class StackOverflowException extends RuntimeException
+{
+    public function __construct(
+        string $message = 'Stack overflow',
+        int $code = 0,
+        Throwable $previous = null,
+    ) {
+        parent::__construct($message, $code, $previous);
+    }
+}
diff --git a/src/WebAssembly/Execution/Store.php b/src/WebAssembly/Execution/Store.php
new file mode 100644
index 0000000..5bef648
--- /dev/null
+++ b/src/WebAssembly/Execution/Store.php
@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+use RuntimeException;
+use function count;
+
+final class Store
+{
+    /**
+     * @param list<FuncInst> $funcs
+     * @param list<TableInst> $tables
+     * @param list<MemInst> $mems
+     * @param list<GlobalInst> $globals
+     * @param list<ElemInst> $elems
+     * @param list<DataInst> $datas
+     */
+    public function __construct(
+        public array $funcs,
+        public array $tables,
+        public array $mems,
+        public array $globals,
+        public array $elems,
+        public array $datas,
+    ) {
+    }
+
+    public static function empty(): self
+    {
+        return new self([], [], [], [], [], []);
+    }
+
+    public function register(Extern $extern): ExternVal
+    {
+        match ($extern::class) {
+            Externs\Func::class => $this->funcs[] = $extern->func,
+            Externs\Table::class => $this->tables[] = $extern->table,
+            Externs\Mem::class => $this->mems[] = $extern->mem,
+            Externs\Global_::class => $this->globals[] = $extern->global,
+            default => throw new RuntimeException("unreachable"),
+        };
+        return match ($extern::class) {
+            Externs\Func::class => ExternVal::Func(count($this->funcs) - 1),
+            Externs\Table::class => ExternVal::Table(count($this->tables) - 1),
+            Externs\Mem::class => ExternVal::Mem(count($this->mems) - 1),
+            Externs\Global_::class => ExternVal::Global_(count($this->globals) - 1),
+            default => throw new RuntimeException("unreachable"),
+        };
+    }
+}
diff --git a/src/WebAssembly/Execution/TableInst.php b/src/WebAssembly/Execution/TableInst.php
new file mode 100644
index 0000000..9f4cbe7
--- /dev/null
+++ b/src/WebAssembly/Execution/TableInst.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\TableType;
+
+final class TableInst
+{
+    /**
+     * @param list<Ref> $elem
+     */
+    public function __construct(
+        public TableType $type,
+        public array $elem,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Execution/TrapException.php b/src/WebAssembly/Execution/TrapException.php
new file mode 100644
index 0000000..449f9ca
--- /dev/null
+++ b/src/WebAssembly/Execution/TrapException.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+use RuntimeException;
+use Throwable;
+
+class TrapException extends RuntimeException
+{
+    private readonly TrapKind $trapKind;
+
+    public function __construct(
+        string $message = "",
+        int $code = 0,
+        ?Throwable $previous = null,
+        TrapKind $trapKind = TrapKind::Unknown,
+    ) {
+        parent::__construct($message, $code, $previous);
+        $this->trapKind = $trapKind;
+    }
+
+    public function getTrapKind(): TrapKind
+    {
+        return $this->trapKind;
+    }
+}
diff --git a/src/WebAssembly/Execution/TrapKind.php b/src/WebAssembly/Execution/TrapKind.php
new file mode 100644
index 0000000..35a4372
--- /dev/null
+++ b/src/WebAssembly/Execution/TrapKind.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Execution;
+
+enum TrapKind
+{
+    case Unknown;
+    case Unreachable;
+    case OutOfBoundsMemoryAccess;
+    case OutOfBoundsTableAccess;
+    case UninitializedElement;
+    case IndirectCallTypeMismatch;
+    case UndefinedElement;
+    case DivideByZero;
+    case IntegerOverflow;
+    case InvalidConversionToInteger;
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instr.php b/src/WebAssembly/Structure/Instructions/Instr.php
new file mode 100644
index 0000000..18531c6
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instr.php
@@ -0,0 +1,971 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control\BlockType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Parametric;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Reference;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Table;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Variable;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\RefType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValType;
+
+abstract readonly class Instr
+{
+    // Numeric instructions
+    final public static function F32Abs(): Numeric\F32Abs
+    {
+        return new Numeric\F32Abs();
+    }
+    final public static function F32Add(): Numeric\F32Add
+    {
+        return new Numeric\F32Add();
+    }
+    final public static function F32Ceil(): Numeric\F32Ceil
+    {
+        return new Numeric\F32Ceil();
+    }
+    /**
+     * @param F32 $value
+     */
+    final public static function F32Const(float $value): Numeric\F32Const
+    {
+        return new Numeric\F32Const($value);
+    }
+    final public static function F32ConvertI32S(): Numeric\F32ConvertI32S
+    {
+        return new Numeric\F32ConvertI32S();
+    }
+    final public static function F32ConvertI32U(): Numeric\F32ConvertI32U
+    {
+        return new Numeric\F32ConvertI32U();
+    }
+    final public static function F32ConvertI64S(): Numeric\F32ConvertI64S
+    {
+        return new Numeric\F32ConvertI64S();
+    }
+    final public static function F32ConvertI64U(): Numeric\F32ConvertI64U
+    {
+        return new Numeric\F32ConvertI64U();
+    }
+    final public static function F32CopySign(): Numeric\F32CopySign
+    {
+        return new Numeric\F32CopySign();
+    }
+    final public static function F32DemoteF64(): Numeric\F32DemoteF64
+    {
+        return new Numeric\F32DemoteF64();
+    }
+    final public static function F32Div(): Numeric\F32Div
+    {
+        return new Numeric\F32Div();
+    }
+    final public static function F32Eq(): Numeric\F32Eq
+    {
+        return new Numeric\F32Eq();
+    }
+    final public static function F32Floor(): Numeric\F32Floor
+    {
+        return new Numeric\F32Floor();
+    }
+    final public static function F32Ge(): Numeric\F32Ge
+    {
+        return new Numeric\F32Ge();
+    }
+    final public static function F32Gt(): Numeric\F32Gt
+    {
+        return new Numeric\F32Gt();
+    }
+    final public static function F32Le(): Numeric\F32Le
+    {
+        return new Numeric\F32Le();
+    }
+    final public static function F32Lt(): Numeric\F32Lt
+    {
+        return new Numeric\F32Lt();
+    }
+    final public static function F32Max(): Numeric\F32Max
+    {
+        return new Numeric\F32Max();
+    }
+    final public static function F32Min(): Numeric\F32Min
+    {
+        return new Numeric\F32Min();
+    }
+    final public static function F32Mul(): Numeric\F32Mul
+    {
+        return new Numeric\F32Mul();
+    }
+    final public static function F32Ne(): Numeric\F32Ne
+    {
+        return new Numeric\F32Ne();
+    }
+    final public static function F32Nearest(): Numeric\F32Nearest
+    {
+        return new Numeric\F32Nearest();
+    }
+    final public static function F32Neg(): Numeric\F32Neg
+    {
+        return new Numeric\F32Neg();
+    }
+    final public static function F32ReinterpretI32(): Numeric\F32ReinterpretI32
+    {
+        return new Numeric\F32ReinterpretI32();
+    }
+    final public static function F32ReinterpretI64(): Numeric\F32ReinterpretI64
+    {
+        return new Numeric\F32ReinterpretI64();
+    }
+    final public static function F32Sqrt(): Numeric\F32Sqrt
+    {
+        return new Numeric\F32Sqrt();
+    }
+    final public static function F32Sub(): Numeric\F32Sub
+    {
+        return new Numeric\F32Sub();
+    }
+    final public static function F32Trunc(): Numeric\F32Trunc
+    {
+        return new Numeric\F32Trunc();
+    }
+    final public static function F64Abs(): Numeric\F64Abs
+    {
+        return new Numeric\F64Abs();
+    }
+    final public static function F64Add(): Numeric\F64Add
+    {
+        return new Numeric\F64Add();
+    }
+    final public static function F64Ceil(): Numeric\F64Ceil
+    {
+        return new Numeric\F64Ceil();
+    }
+    /**
+     * @param F64 $value
+     */
+    final public static function F64Const(float $value): Numeric\F64Const
+    {
+        return new Numeric\F64Const($value);
+    }
+    final public static function F64ConvertI32S(): Numeric\F64ConvertI32S
+    {
+        return new Numeric\F64ConvertI32S();
+    }
+    final public static function F64ConvertI32U(): Numeric\F64ConvertI32U
+    {
+        return new Numeric\F64ConvertI32U();
+    }
+    final public static function F64ConvertI64S(): Numeric\F64ConvertI64S
+    {
+        return new Numeric\F64ConvertI64S();
+    }
+    final public static function F64ConvertI64U(): Numeric\F64ConvertI64U
+    {
+        return new Numeric\F64ConvertI64U();
+    }
+    final public static function F64CopySign(): Numeric\F64CopySign
+    {
+        return new Numeric\F64CopySign();
+    }
+    final public static function F64Div(): Numeric\F64Div
+    {
+        return new Numeric\F64Div();
+    }
+    final public static function F64Eq(): Numeric\F64Eq
+    {
+        return new Numeric\F64Eq();
+    }
+    final public static function F64Floor(): Numeric\F64Floor
+    {
+        return new Numeric\F64Floor();
+    }
+    final public static function F64Ge(): Numeric\F64Ge
+    {
+        return new Numeric\F64Ge();
+    }
+    final public static function F64Gt(): Numeric\F64Gt
+    {
+        return new Numeric\F64Gt();
+    }
+    final public static function F64Le(): Numeric\F64Le
+    {
+        return new Numeric\F64Le();
+    }
+    final public static function F64Lt(): Numeric\F64Lt
+    {
+        return new Numeric\F64Lt();
+    }
+    final public static function F64Max(): Numeric\F64Max
+    {
+        return new Numeric\F64Max();
+    }
+    final public static function F64Min(): Numeric\F64Min
+    {
+        return new Numeric\F64Min();
+    }
+    final public static function F64Mul(): Numeric\F64Mul
+    {
+        return new Numeric\F64Mul();
+    }
+    final public static function F64Ne(): Numeric\F64Ne
+    {
+        return new Numeric\F64Ne();
+    }
+    final public static function F64Nearest(): Numeric\F64Nearest
+    {
+        return new Numeric\F64Nearest();
+    }
+    final public static function F64Neg(): Numeric\F64Neg
+    {
+        return new Numeric\F64Neg();
+    }
+    final public static function F64PromoteF32(): Numeric\F64PromoteF32
+    {
+        return new Numeric\F64PromoteF32();
+    }
+    final public static function F64ReinterpretI32(): Numeric\F64ReinterpretI32
+    {
+        return new Numeric\F64ReinterpretI32();
+    }
+    final public static function F64ReinterpretI64(): Numeric\F64ReinterpretI64
+    {
+        return new Numeric\F64ReinterpretI64();
+    }
+    final public static function F64Sqrt(): Numeric\F64Sqrt
+    {
+        return new Numeric\F64Sqrt();
+    }
+    final public static function F64Sub(): Numeric\F64Sub
+    {
+        return new Numeric\F64Sub();
+    }
+    final public static function F64Trunc(): Numeric\F64Trunc
+    {
+        return new Numeric\F64Trunc();
+    }
+    final public static function I32Add(): Numeric\I32Add
+    {
+        return new Numeric\I32Add();
+    }
+    final public static function I32And(): Numeric\I32And
+    {
+        return new Numeric\I32And();
+    }
+    final public static function I32Clz(): Numeric\I32Clz
+    {
+        return new Numeric\I32Clz();
+    }
+    /**
+     * @param S64 $value
+     */
+    final public static function I32Const(int $value): Numeric\I32Const
+    {
+        return new Numeric\I32Const($value);
+    }
+    final public static function I32Ctz(): Numeric\I32Ctz
+    {
+        return new Numeric\I32Ctz();
+    }
+    final public static function I32DivS(): Numeric\I32DivS
+    {
+        return new Numeric\I32DivS();
+    }
+    final public static function I32DivU(): Numeric\I32DivU
+    {
+        return new Numeric\I32DivU();
+    }
+    final public static function I32Eq(): Numeric\I32Eq
+    {
+        return new Numeric\I32Eq();
+    }
+    final public static function I32Eqz(): Numeric\I32Eqz
+    {
+        return new Numeric\I32Eqz();
+    }
+    final public static function I32Extend16S(): Numeric\I32Extend16S
+    {
+        return new Numeric\I32Extend16S();
+    }
+    final public static function I32Extend8S(): Numeric\I32Extend8S
+    {
+        return new Numeric\I32Extend8S();
+    }
+    final public static function I32GeS(): Numeric\I32GeS
+    {
+        return new Numeric\I32GeS();
+    }
+    final public static function I32GeU(): Numeric\I32GeU
+    {
+        return new Numeric\I32GeU();
+    }
+    final public static function I32GtS(): Numeric\I32GtS
+    {
+        return new Numeric\I32GtS();
+    }
+    final public static function I32GtU(): Numeric\I32GtU
+    {
+        return new Numeric\I32GtU();
+    }
+    final public static function I32LeS(): Numeric\I32LeS
+    {
+        return new Numeric\I32LeS();
+    }
+    final public static function I32LeU(): Numeric\I32LeU
+    {
+        return new Numeric\I32LeU();
+    }
+    final public static function I32LtS(): Numeric\I32LtS
+    {
+        return new Numeric\I32LtS();
+    }
+    final public static function I32LtU(): Numeric\I32LtU
+    {
+        return new Numeric\I32LtU();
+    }
+    final public static function I32Mul(): Numeric\I32Mul
+    {
+        return new Numeric\I32Mul();
+    }
+    final public static function I32Ne(): Numeric\I32Ne
+    {
+        return new Numeric\I32Ne();
+    }
+    final public static function I32Or(): Numeric\I32Or
+    {
+        return new Numeric\I32Or();
+    }
+    final public static function I32Popcnt(): Numeric\I32Popcnt
+    {
+        return new Numeric\I32Popcnt();
+    }
+    final public static function I32ReinterpretF32(): Numeric\I32ReinterpretF32
+    {
+        return new Numeric\I32ReinterpretF32();
+    }
+    final public static function I32ReinterpretF64(): Numeric\I32ReinterpretF64
+    {
+        return new Numeric\I32ReinterpretF64();
+    }
+    final public static function I32RemS(): Numeric\I32RemS
+    {
+        return new Numeric\I32RemS();
+    }
+    final public static function I32RemU(): Numeric\I32RemU
+    {
+        return new Numeric\I32RemU();
+    }
+    final public static function I32RotL(): Numeric\I32RotL
+    {
+        return new Numeric\I32RotL();
+    }
+    final public static function I32RotR(): Numeric\I32RotR
+    {
+        return new Numeric\I32RotR();
+    }
+    final public static function I32Shl(): Numeric\I32Shl
+    {
+        return new Numeric\I32Shl();
+    }
+    final public static function I32ShrS(): Numeric\I32ShrS
+    {
+        return new Numeric\I32ShrS();
+    }
+    final public static function I32ShrU(): Numeric\I32ShrU
+    {
+        return new Numeric\I32ShrU();
+    }
+    final public static function I32Sub(): Numeric\I32Sub
+    {
+        return new Numeric\I32Sub();
+    }
+    final public static function I32TruncF32S(): Numeric\I32TruncF32S
+    {
+        return new Numeric\I32TruncF32S();
+    }
+    final public static function I32TruncF32U(): Numeric\I32TruncF32U
+    {
+        return new Numeric\I32TruncF32U();
+    }
+    final public static function I32TruncF64S(): Numeric\I32TruncF64S
+    {
+        return new Numeric\I32TruncF64S();
+    }
+    final public static function I32TruncF64U(): Numeric\I32TruncF64U
+    {
+        return new Numeric\I32TruncF64U();
+    }
+    final public static function I32TruncSatF32S(): Numeric\I32TruncSatF32S
+    {
+        return new Numeric\I32TruncSatF32S();
+    }
+    final public static function I32TruncSatF32U(): Numeric\I32TruncSatF32U
+    {
+        return new Numeric\I32TruncSatF32U();
+    }
+    final public static function I32TruncSatF64S(): Numeric\I32TruncSatF64S
+    {
+        return new Numeric\I32TruncSatF64S();
+    }
+    final public static function I32TruncSatF64U(): Numeric\I32TruncSatF64U
+    {
+        return new Numeric\I32TruncSatF64U();
+    }
+    final public static function I32WrapI64(): Numeric\I32WrapI64
+    {
+        return new Numeric\I32WrapI64();
+    }
+    final public static function I32Xor(): Numeric\I32Xor
+    {
+        return new Numeric\I32Xor();
+    }
+    final public static function I64Add(): Numeric\I64Add
+    {
+        return new Numeric\I64Add();
+    }
+    final public static function I64And(): Numeric\I64And
+    {
+        return new Numeric\I64And();
+    }
+    final public static function I64Clz(): Numeric\I64Clz
+    {
+        return new Numeric\I64Clz();
+    }
+    /**
+     * @param S64 $value
+     */
+    final public static function I64Const(int $value): Numeric\I64Const
+    {
+        return new Numeric\I64Const($value);
+    }
+    final public static function I64Ctz(): Numeric\I64Ctz
+    {
+        return new Numeric\I64Ctz();
+    }
+    final public static function I64DivS(): Numeric\I64DivS
+    {
+        return new Numeric\I64DivS();
+    }
+    final public static function I64DivU(): Numeric\I64DivU
+    {
+        return new Numeric\I64DivU();
+    }
+    final public static function I64Eq(): Numeric\I64Eq
+    {
+        return new Numeric\I64Eq();
+    }
+    final public static function I64Eqz(): Numeric\I64Eqz
+    {
+        return new Numeric\I64Eqz();
+    }
+    final public static function I64Extend16S(): Numeric\I64Extend16S
+    {
+        return new Numeric\I64Extend16S();
+    }
+    final public static function I64Extend32S(): Numeric\I64Extend32S
+    {
+        return new Numeric\I64Extend32S();
+    }
+    final public static function I64Extend8S(): Numeric\I64Extend8S
+    {
+        return new Numeric\I64Extend8S();
+    }
+    final public static function I64ExtendI32S(): Numeric\I64ExtendI32S
+    {
+        return new Numeric\I64ExtendI32S();
+    }
+    final public static function I64ExtendI32U(): Numeric\I64ExtendI32U
+    {
+        return new Numeric\I64ExtendI32U();
+    }
+    final public static function I64GeS(): Numeric\I64GeS
+    {
+        return new Numeric\I64GeS();
+    }
+    final public static function I64GeU(): Numeric\I64GeU
+    {
+        return new Numeric\I64GeU();
+    }
+    final public static function I64GtS(): Numeric\I64GtS
+    {
+        return new Numeric\I64GtS();
+    }
+    final public static function I64GtU(): Numeric\I64GtU
+    {
+        return new Numeric\I64GtU();
+    }
+    final public static function I64LeS(): Numeric\I64LeS
+    {
+        return new Numeric\I64LeS();
+    }
+    final public static function I64LeU(): Numeric\I64LeU
+    {
+        return new Numeric\I64LeU();
+    }
+    final public static function I64LtS(): Numeric\I64LtS
+    {
+        return new Numeric\I64LtS();
+    }
+    final public static function I64LtU(): Numeric\I64LtU
+    {
+        return new Numeric\I64LtU();
+    }
+    final public static function I64Mul(): Numeric\I64Mul
+    {
+        return new Numeric\I64Mul();
+    }
+    final public static function I64Ne(): Numeric\I64Ne
+    {
+        return new Numeric\I64Ne();
+    }
+    final public static function I64Or(): Numeric\I64Or
+    {
+        return new Numeric\I64Or();
+    }
+    final public static function I64Popcnt(): Numeric\I64Popcnt
+    {
+        return new Numeric\I64Popcnt();
+    }
+    final public static function I64ReinterpretF32(): Numeric\I64ReinterpretF32
+    {
+        return new Numeric\I64ReinterpretF32();
+    }
+    final public static function I64ReinterpretF64(): Numeric\I64ReinterpretF64
+    {
+        return new Numeric\I64ReinterpretF64();
+    }
+    final public static function I64RemS(): Numeric\I64RemS
+    {
+        return new Numeric\I64RemS();
+    }
+    final public static function I64RemU(): Numeric\I64RemU
+    {
+        return new Numeric\I64RemU();
+    }
+    final public static function I64RotL(): Numeric\I64RotL
+    {
+        return new Numeric\I64RotL();
+    }
+    final public static function I64RotR(): Numeric\I64RotR
+    {
+        return new Numeric\I64RotR();
+    }
+    final public static function I64Shl(): Numeric\I64Shl
+    {
+        return new Numeric\I64Shl();
+    }
+    final public static function I64ShrS(): Numeric\I64ShrS
+    {
+        return new Numeric\I64ShrS();
+    }
+    final public static function I64ShrU(): Numeric\I64ShrU
+    {
+        return new Numeric\I64ShrU();
+    }
+    final public static function I64Sub(): Numeric\I64Sub
+    {
+        return new Numeric\I64Sub();
+    }
+    final public static function I64TruncF32S(): Numeric\I64TruncF32S
+    {
+        return new Numeric\I64TruncF32S();
+    }
+    final public static function I64TruncF32U(): Numeric\I64TruncF32U
+    {
+        return new Numeric\I64TruncF32U();
+    }
+    final public static function I64TruncF64S(): Numeric\I64TruncF64S
+    {
+        return new Numeric\I64TruncF64S();
+    }
+    final public static function I64TruncF64U(): Numeric\I64TruncF64U
+    {
+        return new Numeric\I64TruncF64U();
+    }
+    final public static function I64TruncSatF32S(): Numeric\I64TruncSatF32S
+    {
+        return new Numeric\I64TruncSatF32S();
+    }
+    final public static function I64TruncSatF32U(): Numeric\I64TruncSatF32U
+    {
+        return new Numeric\I64TruncSatF32U();
+    }
+    final public static function I64TruncSatF64S(): Numeric\I64TruncSatF64S
+    {
+        return new Numeric\I64TruncSatF64S();
+    }
+    final public static function I64TruncSatF64U(): Numeric\I64TruncSatF64U
+    {
+        return new Numeric\I64TruncSatF64U();
+    }
+    final public static function I64Xor(): Numeric\I64Xor
+    {
+        return new Numeric\I64Xor();
+    }
+
+    // Reference instructions
+    final public static function RefFunc(int $func): Reference\RefFunc
+    {
+        return new Reference\RefFunc($func);
+    }
+    final public static function RefIsNull(): Reference\RefIsNull
+    {
+        return new Reference\RefIsNull();
+    }
+    final public static function RefNull(RefType $type): Reference\RefNull
+    {
+        return new Reference\RefNull($type);
+    }
+
+    // Parametric instructions
+    final public static function Drop(): Parametric\Drop
+    {
+        return new Parametric\Drop();
+    }
+    /**
+     * @param list<ValType> $types
+     */
+    final public static function Select(array $types): Parametric\Select
+    {
+        return new Parametric\Select($types);
+    }
+
+    // Variable instructions
+    final public static function GlobalGet(int $var): Variable\GlobalGet
+    {
+        return new Variable\GlobalGet($var);
+    }
+    final public static function GlobalSet(int $var): Variable\GlobalSet
+    {
+        return new Variable\GlobalSet($var);
+    }
+    final public static function LocalGet(int $var): Variable\LocalGet
+    {
+        return new Variable\LocalGet($var);
+    }
+    final public static function LocalSet(int $var): Variable\LocalSet
+    {
+        return new Variable\LocalSet($var);
+    }
+    final public static function LocalTee(int $var): Variable\LocalTee
+    {
+        return new Variable\LocalTee($var);
+    }
+
+    // Table instructions
+    final public static function ElemDrop(int $elem): Table\ElemDrop
+    {
+        return new Table\ElemDrop($elem);
+    }
+    final public static function TableCopy(int $to, int $from): Table\TableCopy
+    {
+        return new Table\TableCopy($to, $from);
+    }
+    final public static function TableFill(int $table): Table\TableFill
+    {
+        return new Table\TableFill($table);
+    }
+    final public static function TableGet(int $table): Table\TableGet
+    {
+        return new Table\TableGet($table);
+    }
+    final public static function TableGrow(int $table): Table\TableGrow
+    {
+        return new Table\TableGrow($table);
+    }
+    final public static function TableInit(int $to, int $from): Table\TableInit
+    {
+        return new Table\TableInit($to, $from);
+    }
+    final public static function TableSet(int $table): Table\TableSet
+    {
+        return new Table\TableSet($table);
+    }
+    final public static function TableSize(int $table): Table\TableSize
+    {
+        return new Table\TableSize($table);
+    }
+
+    // Memory instructions
+    final public static function DataDrop(int $data): Memory\DataDrop
+    {
+        return new Memory\DataDrop($data);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function F32Load(int $offset, int $align): Memory\F32Load
+    {
+        return new Memory\F32Load($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function F32Store(int $offset, int $align): Memory\F32Store
+    {
+        return new Memory\F32Store($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function F64Load(int $offset, int $align): Memory\F64Load
+    {
+        return new Memory\F64Load($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function F64Store(int $offset, int $align): Memory\F64Store
+    {
+        return new Memory\F64Store($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I32Load(int $offset, int $align): Memory\I32Load
+    {
+        return new Memory\I32Load($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I32Load16S(int $offset, int $align): Memory\I32Load16S
+    {
+        return new Memory\I32Load16S($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I32Load16U(int $offset, int $align): Memory\I32Load16U
+    {
+        return new Memory\I32Load16U($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I32Load8S(int $offset, int $align): Memory\I32Load8S
+    {
+        return new Memory\I32Load8S($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I32Load8U(int $offset, int $align): Memory\I32Load8U
+    {
+        return new Memory\I32Load8U($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I32Store(int $offset, int $align): Memory\I32Store
+    {
+        return new Memory\I32Store($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I32Store16(int $offset, int $align): Memory\I32Store16
+    {
+        return new Memory\I32Store16($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I32Store8(int $offset, int $align): Memory\I32Store8
+    {
+        return new Memory\I32Store8($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I64Load(int $offset, int $align): Memory\I64Load
+    {
+        return new Memory\I64Load($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I64Load16S(int $offset, int $align): Memory\I64Load16S
+    {
+        return new Memory\I64Load16S($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I64Load16U(int $offset, int $align): Memory\I64Load16U
+    {
+        return new Memory\I64Load16U($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I64Load32S(int $offset, int $align): Memory\I64Load32S
+    {
+        return new Memory\I64Load32S($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I64Load32U(int $offset, int $align): Memory\I64Load32U
+    {
+        return new Memory\I64Load32U($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I64Load8S(int $offset, int $align): Memory\I64Load8S
+    {
+        return new Memory\I64Load8S($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I64Load8U(int $offset, int $align): Memory\I64Load8U
+    {
+        return new Memory\I64Load8U($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I64Store(int $offset, int $align): Memory\I64Store
+    {
+        return new Memory\I64Store($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I64Store16(int $offset, int $align): Memory\I64Store16
+    {
+        return new Memory\I64Store16($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I64Store32(int $offset, int $align): Memory\I64Store32
+    {
+        return new Memory\I64Store32($offset, $align);
+    }
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    final public static function I64Store8(int $offset, int $align): Memory\I64Store8
+    {
+        return new Memory\I64Store8($offset, $align);
+    }
+    final public static function MemoryCopy(): Memory\MemoryCopy
+    {
+        return new Memory\MemoryCopy();
+    }
+    final public static function MemoryFill(): Memory\MemoryFill
+    {
+        return new Memory\MemoryFill();
+    }
+    final public static function MemoryGrow(): Memory\MemoryGrow
+    {
+        return new Memory\MemoryGrow();
+    }
+    final public static function MemoryInit(int $data): Memory\MemoryInit
+    {
+        return new Memory\MemoryInit($data);
+    }
+    final public static function MemorySize(): Memory\MemorySize
+    {
+        return new Memory\MemorySize();
+    }
+
+    // Control instructions
+    /**
+     * @param list<Instr> $body
+     */
+    final public static function Block(BlockType $type, array $body): Control\Block
+    {
+        return new Control\Block($type, $body);
+    }
+    final public static function Br(int $label): Control\Br
+    {
+        return new Control\Br($label);
+    }
+    final public static function BrIf(int $label): Control\BrIf
+    {
+        return new Control\BrIf($label);
+    }
+    /**
+     * @param list<int> $labelTable
+     */
+    final public static function BrTable(array $labelTable, int $defaultLabel): Control\BrTable
+    {
+        return new Control\BrTable($labelTable, $defaultLabel);
+    }
+    final public static function Call(int $func): Control\Call
+    {
+        return new Control\Call($func);
+    }
+    final public static function CallIndirect(int $funcTable, int $type): Control\CallIndirect
+    {
+        return new Control\CallIndirect($funcTable, $type);
+    }
+    final public static function Else_(): Control\Else_
+    {
+        return new Control\Else_();
+    }
+    final public static function End(): Control\End
+    {
+        return new Control\End();
+    }
+    /**
+     * @param list<Instr> $thenBody
+     * @param list<Instr> $elseBody
+     */
+    final public static function If_(BlockType $type, array $thenBody, array $elseBody): Control\If_
+    {
+        return new Control\If_($type, $thenBody, $elseBody);
+    }
+    /**
+     * @param list<Instr> $body
+     */
+    final public static function Loop(BlockType $type, array $body): Control\Loop
+    {
+        return new Control\Loop($type, $body);
+    }
+    final public static function Nop(): Control\Nop
+    {
+        return new Control\Nop();
+    }
+    final public static function Return_(): Control\Return_
+    {
+        return new Control\Return_();
+    }
+    final public static function Unreachable(): Control\Unreachable
+    {
+        return new Control\Unreachable();
+    }
+
+    abstract public static function opName(): string;
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/Block.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/Block.php
new file mode 100644
index 0000000..af2c97f
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/Block.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class Block extends Instr
+{
+    /**
+     * @param list<Instr> $body
+     */
+    protected function __construct(
+        public BlockType $type,
+        public array $body,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "block";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/BlockType.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/BlockType.php
new file mode 100644
index 0000000..1188625
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/BlockType.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValType;
+
+abstract readonly class BlockType
+{
+    final public static function TypeIdx(int $type): BlockTypes\TypeIdx
+    {
+        return new BlockTypes\TypeIdx($type);
+    }
+
+    final public static function ValType(?ValType $type): BlockTypes\ValType
+    {
+        return new BlockTypes\ValType($type);
+    }
+
+    public static function opName(): string
+    {
+        return "hoge";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/BlockTypes/TypeIdx.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/BlockTypes/TypeIdx.php
new file mode 100644
index 0000000..2ed694b
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/BlockTypes/TypeIdx.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control\BlockTypes;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control\BlockType;
+
+final readonly class TypeIdx extends BlockType
+{
+    protected function __construct(public int $inner)
+    {
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/BlockTypes/ValType.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/BlockTypes/ValType.php
new file mode 100644
index 0000000..e7caa3f
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/BlockTypes/ValType.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control\BlockTypes;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control\BlockType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValType as OrigValType;
+
+final readonly class ValType extends BlockType
+{
+    protected function __construct(public ?OrigValType $inner)
+    {
+    }
+
+    public static function opName(): string
+    {
+        return "hoge";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/Br.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/Br.php
new file mode 100644
index 0000000..6235a36
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/Br.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class Br extends Instr
+{
+    protected function __construct(
+        public int $label,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "br";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/BrIf.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/BrIf.php
new file mode 100644
index 0000000..7c8a896
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/BrIf.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class BrIf extends Instr
+{
+    protected function __construct(
+        public int $label,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "br_if";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/BrTable.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/BrTable.php
new file mode 100644
index 0000000..2841814
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/BrTable.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class BrTable extends Instr
+{
+    /**
+     * @param list<int> $labelTable
+     */
+    protected function __construct(
+        public array $labelTable,
+        public int $defaultLabel,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "br_table";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/Call.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/Call.php
new file mode 100644
index 0000000..461f561
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/Call.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class Call extends Instr
+{
+    protected function __construct(
+        public int $func,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "call";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/CallIndirect.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/CallIndirect.php
new file mode 100644
index 0000000..7017723
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/CallIndirect.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class CallIndirect extends Instr
+{
+    protected function __construct(
+        public int $funcTable,
+        public int $type,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "call_indirect";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/Else_.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/Else_.php
new file mode 100644
index 0000000..1407543
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/Else_.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class Else_ extends Instr
+{
+    public static function opName(): string
+    {
+        return "else";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/End.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/End.php
new file mode 100644
index 0000000..5bdb8b9
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/End.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class End extends Instr
+{
+    public static function opName(): string
+    {
+        return "end";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/If_.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/If_.php
new file mode 100644
index 0000000..8afdc8b
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/If_.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class If_ extends Instr
+{
+    /**
+     * @param list<Instr> $thenBody
+     * @param list<Instr> $elseBody
+     */
+    protected function __construct(
+        public BlockType $type,
+        public array $thenBody,
+        public array $elseBody,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "if";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/Loop.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/Loop.php
new file mode 100644
index 0000000..ca48ca1
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/Loop.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class Loop extends Instr
+{
+    /**
+     * @param list<Instr> $body
+     */
+    protected function __construct(
+        public BlockType $type,
+        public array $body,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "loop";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/Nop.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/Nop.php
new file mode 100644
index 0000000..50a3773
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/Nop.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class Nop extends Instr
+{
+    public static function opName(): string
+    {
+        return "nop";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/Return_.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/Return_.php
new file mode 100644
index 0000000..b80fdfe
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/Return_.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class Return_ extends Instr
+{
+    public static function opName(): string
+    {
+        return "return";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Control/Unreachable.php b/src/WebAssembly/Structure/Instructions/Instrs/Control/Unreachable.php
new file mode 100644
index 0000000..e43ade8
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Control/Unreachable.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Control;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class Unreachable extends Instr
+{
+    public static function opName(): string
+    {
+        return "unreachable";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/DataDrop.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/DataDrop.php
new file mode 100644
index 0000000..3525b80
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/DataDrop.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class DataDrop extends Instr
+{
+    protected function __construct(
+        public int $data,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "data.drop";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/F32Load.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/F32Load.php
new file mode 100644
index 0000000..82b7cf4
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/F32Load.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Load extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "f32.load";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/F32Store.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/F32Store.php
new file mode 100644
index 0000000..06d9055
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/F32Store.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Store extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "f32.store";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/F64Load.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/F64Load.php
new file mode 100644
index 0000000..13e2385
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/F64Load.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Load extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "f64.load";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/F64Store.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/F64Store.php
new file mode 100644
index 0000000..261b276
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/F64Store.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Store extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "f64.store";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Load.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Load.php
new file mode 100644
index 0000000..4554a77
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Load.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Load extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i32.load";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Load16S.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Load16S.php
new file mode 100644
index 0000000..56bdb3f
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Load16S.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Load16S extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i32.load16_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Load16U.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Load16U.php
new file mode 100644
index 0000000..1cc243c
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Load16U.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Load16U extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i32.load16_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Load8S.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Load8S.php
new file mode 100644
index 0000000..a76607f
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Load8S.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Load8S extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i32.load8_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Load8U.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Load8U.php
new file mode 100644
index 0000000..7cab471
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Load8U.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Load8U extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i32.load8_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Store.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Store.php
new file mode 100644
index 0000000..3021639
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Store.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Store extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i32.store";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Store16.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Store16.php
new file mode 100644
index 0000000..3463fdf
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Store16.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Store16 extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i32.store16";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Store8.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Store8.php
new file mode 100644
index 0000000..5298ad5
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I32Store8.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Store8 extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i32.store8";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load.php
new file mode 100644
index 0000000..33fa4e1
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Load extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i64.load";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load16S.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load16S.php
new file mode 100644
index 0000000..47ef776
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load16S.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Load16S extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i64.load16_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load16U.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load16U.php
new file mode 100644
index 0000000..8825b89
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load16U.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Load16U extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i64.load16_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load32S.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load32S.php
new file mode 100644
index 0000000..bd2575b
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load32S.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Load32S extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i64.load32_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load32U.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load32U.php
new file mode 100644
index 0000000..404bc8a
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load32U.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Load32U extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i64.load32_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load8S.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load8S.php
new file mode 100644
index 0000000..f28bad9
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load8S.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Load8S extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i64.load8_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load8U.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load8U.php
new file mode 100644
index 0000000..66b5575
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Load8U.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Load8U extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i64.load8_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Store.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Store.php
new file mode 100644
index 0000000..0b4778b
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Store.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Store extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i64.store";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Store16.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Store16.php
new file mode 100644
index 0000000..984ecd2
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Store16.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Store16 extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i64.store16";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Store32.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Store32.php
new file mode 100644
index 0000000..e486308
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Store32.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Store32 extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i64.store32";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Store8.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Store8.php
new file mode 100644
index 0000000..7897197
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/I64Store8.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Store8 extends Instr
+{
+    /**
+     * @param U32 $offset
+     * @param U32 $align
+     */
+    protected function __construct(
+        public int $offset,
+        public int $align,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i64.store8";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/MemoryCopy.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/MemoryCopy.php
new file mode 100644
index 0000000..5ef7106
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/MemoryCopy.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class MemoryCopy extends Instr
+{
+    public static function opName(): string
+    {
+        return "memory.copy";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/MemoryFill.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/MemoryFill.php
new file mode 100644
index 0000000..be388ff
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/MemoryFill.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class MemoryFill extends Instr
+{
+    public static function opName(): string
+    {
+        return "memory.fill";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/MemoryGrow.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/MemoryGrow.php
new file mode 100644
index 0000000..9e6c320
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/MemoryGrow.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class MemoryGrow extends Instr
+{
+    public static function opName(): string
+    {
+        return "memory.grow";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/MemoryInit.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/MemoryInit.php
new file mode 100644
index 0000000..7843ff1
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/MemoryInit.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class MemoryInit extends Instr
+{
+    protected function __construct(
+        public int $data,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "memory.init";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Memory/MemorySize.php b/src/WebAssembly/Structure/Instructions/Instrs/Memory/MemorySize.php
new file mode 100644
index 0000000..075878a
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Memory/MemorySize.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Memory;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class MemorySize extends Instr
+{
+    public static function opName(): string
+    {
+        return "memory.size";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Abs.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Abs.php
new file mode 100644
index 0000000..7711f7f
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Abs.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Abs extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.abs";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Add.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Add.php
new file mode 100644
index 0000000..5f92829
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Add.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Add extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.add";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Ceil.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Ceil.php
new file mode 100644
index 0000000..be6f11e
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Ceil.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Ceil extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.ceil";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Const.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Const.php
new file mode 100644
index 0000000..fd2670e
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Const.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Const extends Instr
+{
+    /**
+     * @param F32 $value
+     */
+    protected function __construct(
+        public float $value,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "f32.const";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ConvertI32S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ConvertI32S.php
new file mode 100644
index 0000000..5e68989
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ConvertI32S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32ConvertI32S extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.convert_i32_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ConvertI32U.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ConvertI32U.php
new file mode 100644
index 0000000..fdaa709
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ConvertI32U.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32ConvertI32U extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.convert_i32_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ConvertI64S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ConvertI64S.php
new file mode 100644
index 0000000..b6444cc
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ConvertI64S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32ConvertI64S extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.convert_i64_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ConvertI64U.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ConvertI64U.php
new file mode 100644
index 0000000..4b0f578
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ConvertI64U.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32ConvertI64U extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.convert_i64_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32CopySign.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32CopySign.php
new file mode 100644
index 0000000..539682a
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32CopySign.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32CopySign extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.copy_sign";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32DemoteF64.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32DemoteF64.php
new file mode 100644
index 0000000..24cff4f
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32DemoteF64.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32DemoteF64 extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.demote_f64";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Div.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Div.php
new file mode 100644
index 0000000..3cdafb0
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Div.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Div extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.div";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Eq.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Eq.php
new file mode 100644
index 0000000..cae6c2e
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Eq.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Eq extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.eq";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Floor.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Floor.php
new file mode 100644
index 0000000..9c1b23f
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Floor.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Floor extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.floor";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Ge.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Ge.php
new file mode 100644
index 0000000..ef75922
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Ge.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Ge extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.ge";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Gt.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Gt.php
new file mode 100644
index 0000000..0efda96
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Gt.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Gt extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.gt";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Le.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Le.php
new file mode 100644
index 0000000..50cbb71
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Le.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Le extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.le";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Lt.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Lt.php
new file mode 100644
index 0000000..e4b490a
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Lt.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Lt extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.lt";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Max.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Max.php
new file mode 100644
index 0000000..81f9b3e
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Max.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Max extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.max";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Min.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Min.php
new file mode 100644
index 0000000..20518ea
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Min.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Min extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.min";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Mul.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Mul.php
new file mode 100644
index 0000000..8282273
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Mul.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Mul extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.mul";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Ne.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Ne.php
new file mode 100644
index 0000000..8b5db5e
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Ne.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Ne extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.ne";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Nearest.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Nearest.php
new file mode 100644
index 0000000..ae51359
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Nearest.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Nearest extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.nearest";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Neg.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Neg.php
new file mode 100644
index 0000000..82b72c3
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Neg.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Neg extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.neg";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ReinterpretI32.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ReinterpretI32.php
new file mode 100644
index 0000000..3cd93c4
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ReinterpretI32.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32ReinterpretI32 extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.reinterpret_i32";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ReinterpretI64.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ReinterpretI64.php
new file mode 100644
index 0000000..dd0f66f
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32ReinterpretI64.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32ReinterpretI64 extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.reinterpret_i64";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Sqrt.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Sqrt.php
new file mode 100644
index 0000000..9cdeba2
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Sqrt.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Sqrt extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.sqrt";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Sub.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Sub.php
new file mode 100644
index 0000000..54b5991
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Sub.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Sub extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.sub";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Trunc.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Trunc.php
new file mode 100644
index 0000000..627406e
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F32Trunc.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F32Trunc extends Instr
+{
+    public static function opName(): string
+    {
+        return "f32.trunc";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Abs.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Abs.php
new file mode 100644
index 0000000..a985933
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Abs.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Abs extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.abs";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Add.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Add.php
new file mode 100644
index 0000000..60a6a05
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Add.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Add extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.add";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Ceil.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Ceil.php
new file mode 100644
index 0000000..3c88a4b
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Ceil.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Ceil extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.ceil";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Const.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Const.php
new file mode 100644
index 0000000..46c61fe
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Const.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Const extends Instr
+{
+    /**
+     * @param F64 $value
+     */
+    protected function __construct(
+        public float $value,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "f64.const";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ConvertI32S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ConvertI32S.php
new file mode 100644
index 0000000..5deaec0
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ConvertI32S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64ConvertI32S extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.convert_i32_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ConvertI32U.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ConvertI32U.php
new file mode 100644
index 0000000..657e8e2
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ConvertI32U.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64ConvertI32U extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.convert_i32_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ConvertI64S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ConvertI64S.php
new file mode 100644
index 0000000..af7d5af
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ConvertI64S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64ConvertI64S extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.convert_i64_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ConvertI64U.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ConvertI64U.php
new file mode 100644
index 0000000..575c8e5
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ConvertI64U.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64ConvertI64U extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.convert_i64_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64CopySign.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64CopySign.php
new file mode 100644
index 0000000..bab91f2
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64CopySign.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64CopySign extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.copy_sign";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Div.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Div.php
new file mode 100644
index 0000000..7304a8d
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Div.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Div extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.div";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Eq.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Eq.php
new file mode 100644
index 0000000..1c9e31c
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Eq.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Eq extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.eq";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Floor.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Floor.php
new file mode 100644
index 0000000..8c76753
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Floor.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Floor extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.floor";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Ge.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Ge.php
new file mode 100644
index 0000000..28f6da1
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Ge.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Ge extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.ge";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Gt.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Gt.php
new file mode 100644
index 0000000..9b6e91e
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Gt.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Gt extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.gt";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Le.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Le.php
new file mode 100644
index 0000000..1852d66
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Le.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Le extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.le";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Lt.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Lt.php
new file mode 100644
index 0000000..fb96301
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Lt.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Lt extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.lt";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Max.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Max.php
new file mode 100644
index 0000000..da79a2e
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Max.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Max extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.max";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Min.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Min.php
new file mode 100644
index 0000000..79bb77b
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Min.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Min extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.min";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Mul.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Mul.php
new file mode 100644
index 0000000..f0932ea
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Mul.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Mul extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.mul";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Ne.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Ne.php
new file mode 100644
index 0000000..226b1e4
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Ne.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Ne extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.ne";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Nearest.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Nearest.php
new file mode 100644
index 0000000..0863099
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Nearest.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Nearest extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.nearest";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Neg.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Neg.php
new file mode 100644
index 0000000..c4e0ce7
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Neg.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Neg extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.neg";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64PromoteF32.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64PromoteF32.php
new file mode 100644
index 0000000..8692806
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64PromoteF32.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64PromoteF32 extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.promote_f32";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ReinterpretI32.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ReinterpretI32.php
new file mode 100644
index 0000000..4721e07
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ReinterpretI32.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64ReinterpretI32 extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.reinterpret_i32";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ReinterpretI64.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ReinterpretI64.php
new file mode 100644
index 0000000..22faa67
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64ReinterpretI64.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64ReinterpretI64 extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.reinterpret_i64";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Sqrt.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Sqrt.php
new file mode 100644
index 0000000..77d708a
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Sqrt.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Sqrt extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.sqrt";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Sub.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Sub.php
new file mode 100644
index 0000000..b20c0c9
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Sub.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Sub extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.sub";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Trunc.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Trunc.php
new file mode 100644
index 0000000..62d6c12
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/F64Trunc.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class F64Trunc extends Instr
+{
+    public static function opName(): string
+    {
+        return "f64.trunc";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Add.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Add.php
new file mode 100644
index 0000000..429dfdf
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Add.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Add extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.add";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32And.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32And.php
new file mode 100644
index 0000000..135f038
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32And.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32And extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.and";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Clz.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Clz.php
new file mode 100644
index 0000000..7bdfa52
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Clz.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Clz extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.clz";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Const.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Const.php
new file mode 100644
index 0000000..4900a1c
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Const.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Const extends Instr
+{
+    /**
+     * @param U32 $value
+     */
+    protected function __construct(
+        public int $value,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i32.const";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Ctz.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Ctz.php
new file mode 100644
index 0000000..4577729
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Ctz.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Ctz extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.ctz";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32DivS.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32DivS.php
new file mode 100644
index 0000000..bbc0f08
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32DivS.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32DivS extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.div_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32DivU.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32DivU.php
new file mode 100644
index 0000000..3db3fa0
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32DivU.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32DivU extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.div_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Eq.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Eq.php
new file mode 100644
index 0000000..eb24aad
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Eq.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Eq extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.eq";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Eqz.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Eqz.php
new file mode 100644
index 0000000..b99341a
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Eqz.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Eqz extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.eqz";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Extend16S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Extend16S.php
new file mode 100644
index 0000000..50e3951
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Extend16S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Extend16S extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.extend16_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Extend8S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Extend8S.php
new file mode 100644
index 0000000..9f5aa4b
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Extend8S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Extend8S extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.extend8_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32GeS.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32GeS.php
new file mode 100644
index 0000000..7f2746f
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32GeS.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32GeS extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.ge_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32GeU.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32GeU.php
new file mode 100644
index 0000000..3018605
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32GeU.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32GeU extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.ge_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32GtS.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32GtS.php
new file mode 100644
index 0000000..093f47d
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32GtS.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32GtS extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.gt_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32GtU.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32GtU.php
new file mode 100644
index 0000000..e7c07e3
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32GtU.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32GtU extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.gt_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32LeS.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32LeS.php
new file mode 100644
index 0000000..078535a
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32LeS.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32LeS extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.le_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32LeU.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32LeU.php
new file mode 100644
index 0000000..0fe2ae2
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32LeU.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32LeU extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.le_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32LtS.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32LtS.php
new file mode 100644
index 0000000..6070881
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32LtS.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32LtS extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.lt_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32LtU.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32LtU.php
new file mode 100644
index 0000000..ccb520e
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32LtU.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32LtU extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.lt_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Mul.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Mul.php
new file mode 100644
index 0000000..7ddf1e6
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Mul.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Mul extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.mul";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Ne.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Ne.php
new file mode 100644
index 0000000..7624909
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Ne.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Ne extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.ne";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Or.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Or.php
new file mode 100644
index 0000000..4d985a7
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Or.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Or extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.or";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Popcnt.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Popcnt.php
new file mode 100644
index 0000000..ea2e5af
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Popcnt.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Popcnt extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.popcnt";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32ReinterpretF32.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32ReinterpretF32.php
new file mode 100644
index 0000000..3ca1a3c
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32ReinterpretF32.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32ReinterpretF32 extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.reinterpret_f32";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32ReinterpretF64.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32ReinterpretF64.php
new file mode 100644
index 0000000..2990a21
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32ReinterpretF64.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32ReinterpretF64 extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.reinterpret_f64";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32RemS.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32RemS.php
new file mode 100644
index 0000000..0814085
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32RemS.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32RemS extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.rem_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32RemU.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32RemU.php
new file mode 100644
index 0000000..b945e4e
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32RemU.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32RemU extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.rem_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32RotL.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32RotL.php
new file mode 100644
index 0000000..509a39e
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32RotL.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32RotL extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.rot_l";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32RotR.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32RotR.php
new file mode 100644
index 0000000..7104869
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32RotR.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32RotR extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.rot_r";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Shl.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Shl.php
new file mode 100644
index 0000000..199cace
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Shl.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Shl extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.shl";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32ShrS.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32ShrS.php
new file mode 100644
index 0000000..5645907
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32ShrS.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32ShrS extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.shr_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32ShrU.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32ShrU.php
new file mode 100644
index 0000000..c5435cd
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32ShrU.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32ShrU extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.shr_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Sub.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Sub.php
new file mode 100644
index 0000000..5ca4dec
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Sub.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Sub extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.sub";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncF32S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncF32S.php
new file mode 100644
index 0000000..31ab093
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncF32S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32TruncF32S extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.trunc_f32_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncF32U.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncF32U.php
new file mode 100644
index 0000000..afeda9c
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncF32U.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32TruncF32U extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.trunc_f32_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncF64S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncF64S.php
new file mode 100644
index 0000000..8b27805
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncF64S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32TruncF64S extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.trunc_f64_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncF64U.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncF64U.php
new file mode 100644
index 0000000..5b7550c
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncF64U.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32TruncF64U extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.trunc_f64_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncSatF32S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncSatF32S.php
new file mode 100644
index 0000000..c2fbdf1
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncSatF32S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32TruncSatF32S extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.trunc_sat_f32_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncSatF32U.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncSatF32U.php
new file mode 100644
index 0000000..0ae1090
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncSatF32U.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32TruncSatF32U extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.trunc_sat_f32_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncSatF64S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncSatF64S.php
new file mode 100644
index 0000000..38731db
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncSatF64S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32TruncSatF64S extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.trunc_sat_f64_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncSatF64U.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncSatF64U.php
new file mode 100644
index 0000000..22f5335
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32TruncSatF64U.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32TruncSatF64U extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.trunc_sat_f64_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32WrapI64.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32WrapI64.php
new file mode 100644
index 0000000..9c7ed4b
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32WrapI64.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32WrapI64 extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.wrap_i64";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Xor.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Xor.php
new file mode 100644
index 0000000..804b881
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I32Xor.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I32Xor extends Instr
+{
+    public static function opName(): string
+    {
+        return "i32.xor";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Add.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Add.php
new file mode 100644
index 0000000..9d81af7
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Add.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Add extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.add";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64And.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64And.php
new file mode 100644
index 0000000..4c1f4b3
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64And.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64And extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.and";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Clz.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Clz.php
new file mode 100644
index 0000000..eb03da7
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Clz.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Clz extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.clz";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Const.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Const.php
new file mode 100644
index 0000000..01e9e72
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Const.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Const extends Instr
+{
+    /**
+     * @param U64 $value
+     */
+    protected function __construct(
+        public int $value,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "i64.const";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Ctz.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Ctz.php
new file mode 100644
index 0000000..3c6fdaa
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Ctz.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Ctz extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.ctz";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64DivS.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64DivS.php
new file mode 100644
index 0000000..8a8759b
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64DivS.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64DivS extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.div_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64DivU.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64DivU.php
new file mode 100644
index 0000000..67f50f7
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64DivU.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64DivU extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.div_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Eq.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Eq.php
new file mode 100644
index 0000000..5480197
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Eq.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Eq extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.eq";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Eqz.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Eqz.php
new file mode 100644
index 0000000..8bd7f04
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Eqz.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Eqz extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.eqz";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Extend16S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Extend16S.php
new file mode 100644
index 0000000..8733d84
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Extend16S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Extend16S extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.extend16_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Extend32S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Extend32S.php
new file mode 100644
index 0000000..3594cf4
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Extend32S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Extend32S extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.extend32_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Extend8S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Extend8S.php
new file mode 100644
index 0000000..8579635
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Extend8S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Extend8S extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.extend8_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ExtendI32S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ExtendI32S.php
new file mode 100644
index 0000000..9db4c55
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ExtendI32S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64ExtendI32S extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.extend_i32_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ExtendI32U.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ExtendI32U.php
new file mode 100644
index 0000000..9219f97
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ExtendI32U.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64ExtendI32U extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.extend_i32_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64GeS.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64GeS.php
new file mode 100644
index 0000000..bddbffb
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64GeS.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64GeS extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.ge_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64GeU.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64GeU.php
new file mode 100644
index 0000000..9b5df84
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64GeU.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64GeU extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.ge_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64GtS.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64GtS.php
new file mode 100644
index 0000000..4ac4063
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64GtS.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64GtS extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.gt_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64GtU.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64GtU.php
new file mode 100644
index 0000000..4cd0f84
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64GtU.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64GtU extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.gt_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64LeS.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64LeS.php
new file mode 100644
index 0000000..259cc99
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64LeS.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64LeS extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.le_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64LeU.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64LeU.php
new file mode 100644
index 0000000..69c880b
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64LeU.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64LeU extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.le_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64LtS.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64LtS.php
new file mode 100644
index 0000000..9c8d434
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64LtS.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64LtS extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.lt_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64LtU.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64LtU.php
new file mode 100644
index 0000000..8142792
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64LtU.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64LtU extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.lt_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Mul.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Mul.php
new file mode 100644
index 0000000..1a69448
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Mul.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Mul extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.mul";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Ne.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Ne.php
new file mode 100644
index 0000000..4cf363e
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Ne.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Ne extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.ne";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Or.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Or.php
new file mode 100644
index 0000000..c09caab
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Or.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Or extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.or";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Popcnt.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Popcnt.php
new file mode 100644
index 0000000..3db978b
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Popcnt.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Popcnt extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.popcnt";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ReinterpretF32.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ReinterpretF32.php
new file mode 100644
index 0000000..6446e50
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ReinterpretF32.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64ReinterpretF32 extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.reinterpret_f32";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ReinterpretF64.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ReinterpretF64.php
new file mode 100644
index 0000000..b570008
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ReinterpretF64.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64ReinterpretF64 extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.reinterpret_f64";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64RemS.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64RemS.php
new file mode 100644
index 0000000..7833dcd
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64RemS.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64RemS extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.rem_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64RemU.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64RemU.php
new file mode 100644
index 0000000..97117dc
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64RemU.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64RemU extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.rem_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64RotL.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64RotL.php
new file mode 100644
index 0000000..b39a2ac
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64RotL.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64RotL extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.rot_l";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64RotR.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64RotR.php
new file mode 100644
index 0000000..aa62ee8
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64RotR.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64RotR extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.rot_r";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Shl.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Shl.php
new file mode 100644
index 0000000..f43018a
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Shl.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Shl extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.shl";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ShrS.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ShrS.php
new file mode 100644
index 0000000..f8da95e
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ShrS.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64ShrS extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.shr_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ShrU.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ShrU.php
new file mode 100644
index 0000000..7ea2b3a
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64ShrU.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64ShrU extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.shr_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Sub.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Sub.php
new file mode 100644
index 0000000..7cb6f26
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Sub.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Sub extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.sub";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncF32S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncF32S.php
new file mode 100644
index 0000000..9f6ed66
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncF32S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64TruncF32S extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.trunc_f32_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncF32U.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncF32U.php
new file mode 100644
index 0000000..9724897
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncF32U.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64TruncF32U extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.trunc_f32_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncF64S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncF64S.php
new file mode 100644
index 0000000..70c235c
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncF64S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64TruncF64S extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.trunc_f64_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncF64U.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncF64U.php
new file mode 100644
index 0000000..f787fe3
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncF64U.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64TruncF64U extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.trunc_f64_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncSatF32S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncSatF32S.php
new file mode 100644
index 0000000..98082e5
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncSatF32S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64TruncSatF32S extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.trunc_sat_f32_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncSatF32U.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncSatF32U.php
new file mode 100644
index 0000000..6b0b833
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncSatF32U.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64TruncSatF32U extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.trunc_sat_f32_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncSatF64S.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncSatF64S.php
new file mode 100644
index 0000000..2291eab
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncSatF64S.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64TruncSatF64S extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.trunc_sat_f64_s";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncSatF64U.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncSatF64U.php
new file mode 100644
index 0000000..90c1f49
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64TruncSatF64U.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64TruncSatF64U extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.trunc_sat_f64_u";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Xor.php b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Xor.php
new file mode 100644
index 0000000..994e47f
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Numeric/I64Xor.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Numeric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class I64Xor extends Instr
+{
+    public static function opName(): string
+    {
+        return "i64.xor";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Parametric/Drop.php b/src/WebAssembly/Structure/Instructions/Instrs/Parametric/Drop.php
new file mode 100644
index 0000000..5a5ed18
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Parametric/Drop.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Parametric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class Drop extends Instr
+{
+    public static function opName(): string
+    {
+        return "drop";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Parametric/Select.php b/src/WebAssembly/Structure/Instructions/Instrs/Parametric/Select.php
new file mode 100644
index 0000000..2562764
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Parametric/Select.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Parametric;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValType;
+
+final readonly class Select extends Instr
+{
+    /**
+     * @param list<ValType> $types
+     */
+    protected function __construct(
+        public array $types,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "select";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Reference/RefFunc.php b/src/WebAssembly/Structure/Instructions/Instrs/Reference/RefFunc.php
new file mode 100644
index 0000000..3539ede
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Reference/RefFunc.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Reference;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class RefFunc extends Instr
+{
+    protected function __construct(
+        public int $func,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "ref.func";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Reference/RefIsNull.php b/src/WebAssembly/Structure/Instructions/Instrs/Reference/RefIsNull.php
new file mode 100644
index 0000000..21c9a26
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Reference/RefIsNull.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Reference;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class RefIsNull extends Instr
+{
+    public static function opName(): string
+    {
+        return "ref.is_null";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Reference/RefNull.php b/src/WebAssembly/Structure/Instructions/Instrs/Reference/RefNull.php
new file mode 100644
index 0000000..39d0f8f
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Reference/RefNull.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Reference;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\RefType;
+
+final readonly class RefNull extends Instr
+{
+    protected function __construct(
+        public RefType $type,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "ref.null";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Table/ElemDrop.php b/src/WebAssembly/Structure/Instructions/Instrs/Table/ElemDrop.php
new file mode 100644
index 0000000..4ead3cb
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Table/ElemDrop.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Table;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class ElemDrop extends Instr
+{
+    protected function __construct(
+        public int $elem,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "elem.drop";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Table/TableCopy.php b/src/WebAssembly/Structure/Instructions/Instrs/Table/TableCopy.php
new file mode 100644
index 0000000..ca4e01a
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Table/TableCopy.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Table;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class TableCopy extends Instr
+{
+    protected function __construct(
+        public int $to,
+        public int $from,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "table.copy";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Table/TableFill.php b/src/WebAssembly/Structure/Instructions/Instrs/Table/TableFill.php
new file mode 100644
index 0000000..8a8fba4
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Table/TableFill.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Table;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class TableFill extends Instr
+{
+    protected function __construct(
+        public int $table,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "table.fill";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Table/TableGet.php b/src/WebAssembly/Structure/Instructions/Instrs/Table/TableGet.php
new file mode 100644
index 0000000..0a562cb
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Table/TableGet.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Table;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class TableGet extends Instr
+{
+    protected function __construct(
+        public int $table,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "table.get";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Table/TableGrow.php b/src/WebAssembly/Structure/Instructions/Instrs/Table/TableGrow.php
new file mode 100644
index 0000000..fae1bd0
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Table/TableGrow.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Table;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class TableGrow extends Instr
+{
+    protected function __construct(
+        public int $table,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "table.grow";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Table/TableInit.php b/src/WebAssembly/Structure/Instructions/Instrs/Table/TableInit.php
new file mode 100644
index 0000000..221c938
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Table/TableInit.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Table;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class TableInit extends Instr
+{
+    protected function __construct(
+        public int $to,
+        public int $from,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "table.init";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Table/TableSet.php b/src/WebAssembly/Structure/Instructions/Instrs/Table/TableSet.php
new file mode 100644
index 0000000..46ce56f
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Table/TableSet.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Table;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class TableSet extends Instr
+{
+    protected function __construct(
+        public int $table,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "table.set";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Table/TableSize.php b/src/WebAssembly/Structure/Instructions/Instrs/Table/TableSize.php
new file mode 100644
index 0000000..8a1625a
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Table/TableSize.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Table;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class TableSize extends Instr
+{
+    protected function __construct(
+        public int $table,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "table.size";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Variable/GlobalGet.php b/src/WebAssembly/Structure/Instructions/Instrs/Variable/GlobalGet.php
new file mode 100644
index 0000000..2358325
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Variable/GlobalGet.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Variable;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class GlobalGet extends Instr
+{
+    protected function __construct(
+        public int $var,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "global.get";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Variable/GlobalSet.php b/src/WebAssembly/Structure/Instructions/Instrs/Variable/GlobalSet.php
new file mode 100644
index 0000000..a8d2cf4
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Variable/GlobalSet.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Variable;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class GlobalSet extends Instr
+{
+    protected function __construct(
+        public int $var,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "global.set";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Variable/LocalGet.php b/src/WebAssembly/Structure/Instructions/Instrs/Variable/LocalGet.php
new file mode 100644
index 0000000..de610d3
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Variable/LocalGet.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Variable;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class LocalGet extends Instr
+{
+    protected function __construct(
+        public int $var,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "local.get";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Variable/LocalSet.php b/src/WebAssembly/Structure/Instructions/Instrs/Variable/LocalSet.php
new file mode 100644
index 0000000..350c6bd
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Variable/LocalSet.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Variable;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class LocalSet extends Instr
+{
+    protected function __construct(
+        public int $var,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "local.set";
+    }
+}
diff --git a/src/WebAssembly/Structure/Instructions/Instrs/Variable/LocalTee.php b/src/WebAssembly/Structure/Instructions/Instrs/Variable/LocalTee.php
new file mode 100644
index 0000000..62d42c5
--- /dev/null
+++ b/src/WebAssembly/Structure/Instructions/Instrs/Variable/LocalTee.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instrs\Variable;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class LocalTee extends Instr
+{
+    protected function __construct(
+        public int $var,
+    ) {
+    }
+
+    public static function opName(): string
+    {
+        return "local.tee";
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/Data.php b/src/WebAssembly/Structure/Modules/Data.php
new file mode 100644
index 0000000..3994a01
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/Data.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules;
+
+final readonly class Data
+{
+    /**
+     * @param list<Byte> $init
+     */
+    public function __construct(
+        public array $init,
+        public DataMode $mode,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/DataMode.php b/src/WebAssembly/Structure/Modules/DataMode.php
new file mode 100644
index 0000000..37205bc
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/DataMode.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+abstract readonly class DataMode
+{
+    final public static function Passive(): DataModes\Passive
+    {
+        return new DataModes\Passive();
+    }
+
+    /**
+     * @param list<Instr> $offset
+     */
+    final public static function Active(
+        int $memory,
+        array $offset,
+    ): DataModes\Active {
+        return new DataModes\Active($memory, $offset);
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/DataModes/Active.php b/src/WebAssembly/Structure/Modules/DataModes/Active.php
new file mode 100644
index 0000000..41cc9c7
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/DataModes/Active.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\DataModes;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\DataMode;
+
+final readonly class Active extends DataMode
+{
+    /**
+     * @param list<Instr> $offset
+     */
+    protected function __construct(
+        public int $memory,
+        public array $offset,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/DataModes/Passive.php b/src/WebAssembly/Structure/Modules/DataModes/Passive.php
new file mode 100644
index 0000000..6ef6ba9
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/DataModes/Passive.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\DataModes;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\DataMode;
+
+final readonly class Passive extends DataMode
+{
+    protected function __construct()
+    {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/Elem.php b/src/WebAssembly/Structure/Modules/Elem.php
new file mode 100644
index 0000000..1b9831f
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/Elem.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\RefType;
+
+final readonly class Elem
+{
+    /**
+     * @param list<list<Instr>> $init
+     */
+    public function __construct(
+        public RefType $type,
+        public array $init,
+        public ElemMode $mode,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/ElemMode.php b/src/WebAssembly/Structure/Modules/ElemMode.php
new file mode 100644
index 0000000..0777bd4
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/ElemMode.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+abstract readonly class ElemMode
+{
+    final public static function Passive(): ElemModes\Passive
+    {
+        return new ElemModes\Passive();
+    }
+
+    /**
+     * @param list<Instr> $offset
+     */
+    final public static function Active(
+        int $table,
+        array $offset,
+    ): ElemModes\Active {
+        return new ElemModes\Active($table, $offset);
+    }
+
+    final public static function Declarative(): ElemModes\Declarative
+    {
+        return new ElemModes\Declarative();
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/ElemModes/Active.php b/src/WebAssembly/Structure/Modules/ElemModes/Active.php
new file mode 100644
index 0000000..e66e080
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/ElemModes/Active.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ElemModes;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ElemMode;
+
+final readonly class Active extends ElemMode
+{
+    /**
+     * @param list<Instr> $offset
+     */
+    protected function __construct(
+        public int $table,
+        public array $offset,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/ElemModes/Declarative.php b/src/WebAssembly/Structure/Modules/ElemModes/Declarative.php
new file mode 100644
index 0000000..28f917a
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/ElemModes/Declarative.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ElemModes;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ElemMode;
+
+final readonly class Declarative extends ElemMode
+{
+    protected function __construct()
+    {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/ElemModes/Passive.php b/src/WebAssembly/Structure/Modules/ElemModes/Passive.php
new file mode 100644
index 0000000..5fb323e
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/ElemModes/Passive.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ElemModes;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ElemMode;
+
+final readonly class Passive extends ElemMode
+{
+    protected function __construct()
+    {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/Export.php b/src/WebAssembly/Structure/Modules/Export.php
new file mode 100644
index 0000000..fea3f04
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/Export.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules;
+
+final readonly class Export
+{
+    /**
+     * @param Name $name
+     */
+    public function __construct(
+        public string $name,
+        public ExportDesc $desc,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/ExportDesc.php b/src/WebAssembly/Structure/Modules/ExportDesc.php
new file mode 100644
index 0000000..3462569
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/ExportDesc.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules;
+
+abstract readonly class ExportDesc
+{
+    final public static function Func(int $func): ExportDescs\Func
+    {
+        return new ExportDescs\Func($func);
+    }
+
+    final public static function Table(int $table): ExportDescs\Table
+    {
+        return new ExportDescs\Table($table);
+    }
+
+    final public static function Mem(int $mem): ExportDescs\Mem
+    {
+        return new ExportDescs\Mem($mem);
+    }
+
+    final public static function Global(int $global): ExportDescs\Global_
+    {
+        return new ExportDescs\Global_($global);
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/ExportDescs/Func.php b/src/WebAssembly/Structure/Modules/ExportDescs/Func.php
new file mode 100644
index 0000000..85926c6
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/ExportDescs/Func.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ExportDescs;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ExportDesc;
+
+final readonly class Func extends ExportDesc
+{
+    protected function __construct(
+        public int $func,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/ExportDescs/Global_.php b/src/WebAssembly/Structure/Modules/ExportDescs/Global_.php
new file mode 100644
index 0000000..9e1d481
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/ExportDescs/Global_.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ExportDescs;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ExportDesc;
+
+final readonly class Global_ extends ExportDesc
+{
+    protected function __construct(
+        public int $global,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/ExportDescs/Mem.php b/src/WebAssembly/Structure/Modules/ExportDescs/Mem.php
new file mode 100644
index 0000000..9212f45
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/ExportDescs/Mem.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ExportDescs;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ExportDesc;
+
+final readonly class Mem extends ExportDesc
+{
+    protected function __construct(
+        public int $mem,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/ExportDescs/Table.php b/src/WebAssembly/Structure/Modules/ExportDescs/Table.php
new file mode 100644
index 0000000..e89f2d8
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/ExportDescs/Table.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ExportDescs;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ExportDesc;
+
+final readonly class Table extends ExportDesc
+{
+    protected function __construct(
+        public int $table,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/Func.php b/src/WebAssembly/Structure/Modules/Func.php
new file mode 100644
index 0000000..f1c305e
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/Func.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+
+final readonly class Func
+{
+    /**
+     * @param list<Local> $locals
+     * @param list<Instr> $body
+     */
+    public function __construct(
+        public int $type,
+        public array $locals,
+        public array $body,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/Global_.php b/src/WebAssembly/Structure/Modules/Global_.php
new file mode 100644
index 0000000..04ffbc6
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/Global_.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Instructions\Instr;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\GlobalType;
+
+final readonly class Global_
+{
+    /**
+     * @param list<Instr> $init
+     */
+    public function __construct(
+        public GlobalType $type,
+        public array $init,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/Import.php b/src/WebAssembly/Structure/Modules/Import.php
new file mode 100644
index 0000000..e764fcb
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/Import.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules;
+
+final readonly class Import
+{
+    /**
+     * @param Name $module
+     * @param Name $name
+     */
+    public function __construct(
+        public string $module,
+        public string $name,
+        public ImportDesc $desc,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/ImportDesc.php b/src/WebAssembly/Structure/Modules/ImportDesc.php
new file mode 100644
index 0000000..240ad2b
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/ImportDesc.php
@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\GlobalType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\MemType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\TableType;
+
+abstract readonly class ImportDesc
+{
+    final public static function Func(int $func): ImportDescs\Func
+    {
+        return new ImportDescs\Func($func);
+    }
+
+    final public static function Table(TableType $table): ImportDescs\Table
+    {
+        return new ImportDescs\Table($table);
+    }
+
+    final public static function Mem(MemType $mem): ImportDescs\Mem
+    {
+        return new ImportDescs\Mem($mem);
+    }
+
+    final public static function Global(GlobalType $global): ImportDescs\Global_
+    {
+        return new ImportDescs\Global_($global);
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/ImportDescs/Func.php b/src/WebAssembly/Structure/Modules/ImportDescs/Func.php
new file mode 100644
index 0000000..4b5da18
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/ImportDescs/Func.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ImportDescs;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ImportDesc;
+
+final readonly class Func extends ImportDesc
+{
+    protected function __construct(
+        public int $func,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/ImportDescs/Global_.php b/src/WebAssembly/Structure/Modules/ImportDescs/Global_.php
new file mode 100644
index 0000000..bab51b9
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/ImportDescs/Global_.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ImportDescs;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ImportDesc;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\GlobalType;
+
+final readonly class Global_ extends ImportDesc
+{
+    protected function __construct(
+        public GlobalType $global,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/ImportDescs/Mem.php b/src/WebAssembly/Structure/Modules/ImportDescs/Mem.php
new file mode 100644
index 0000000..934d1c9
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/ImportDescs/Mem.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ImportDescs;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ImportDesc;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\MemType;
+
+final readonly class Mem extends ImportDesc
+{
+    protected function __construct(
+        public MemType $mem,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/ImportDescs/Table.php b/src/WebAssembly/Structure/Modules/ImportDescs/Table.php
new file mode 100644
index 0000000..f8b2fa3
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/ImportDescs/Table.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ImportDescs;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Modules\ImportDesc;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\TableType;
+
+final readonly class Table extends ImportDesc
+{
+    protected function __construct(
+        public TableType $table,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/Local.php b/src/WebAssembly/Structure/Modules/Local.php
new file mode 100644
index 0000000..699d7a3
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/Local.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValType;
+
+final readonly class Local
+{
+    public function __construct(
+        public ValType $type,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/Mem.php b/src/WebAssembly/Structure/Modules/Mem.php
new file mode 100644
index 0000000..45f0066
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/Mem.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\MemType;
+
+final readonly class Mem
+{
+    public function __construct(
+        public MemType $type,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/Module.php b/src/WebAssembly/Structure/Modules/Module.php
new file mode 100644
index 0000000..a6ce2c8
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/Module.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\FuncType;
+
+final readonly class Module
+{
+    /**
+     * @param list<FuncType> $types
+     * @param list<Func> $funcs
+     * @param list<Table> $tables
+     * @param list<Mem> $mems
+     * @param list<Global_> $globals
+     * @param list<Elem> $elems
+     * @param list<Data> $datas
+     * @param list<Import> $imports
+     * @param list<Export> $exports
+     */
+    public function __construct(
+        public array $types,
+        public array $funcs,
+        public array $tables,
+        public array $mems,
+        public array $globals,
+        public array $elems,
+        public array $datas,
+        public ?Start $start,
+        public array $imports,
+        public array $exports,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/Start.php b/src/WebAssembly/Structure/Modules/Start.php
new file mode 100644
index 0000000..6659929
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/Start.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules;
+
+final readonly class Start
+{
+    public function __construct(
+        public int $func,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Modules/Table.php b/src/WebAssembly/Structure/Modules/Table.php
new file mode 100644
index 0000000..f0125a2
--- /dev/null
+++ b/src/WebAssembly/Structure/Modules/Table.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Modules;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\TableType;
+
+final readonly class Table
+{
+    public function __construct(
+        public TableType $type,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Types/ExternType.php b/src/WebAssembly/Structure/Types/ExternType.php
new file mode 100644
index 0000000..bffeacf
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/ExternType.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types;
+
+abstract readonly class ExternType
+{
+    final public static function Func(FuncType $type): ExternTypes\Func
+    {
+        return new ExternTypes\Func($type);
+    }
+
+    final public static function Table(TableType $type): ExternTypes\Table
+    {
+        return new ExternTypes\Table($type);
+    }
+
+    final public static function Mem(MemType $type): ExternTypes\Mem
+    {
+        return new ExternTypes\Mem($type);
+    }
+
+    final public static function Global(GlobalType $type): ExternTypes\Global_
+    {
+        return new ExternTypes\Global_($type);
+    }
+}
diff --git a/src/WebAssembly/Structure/Types/ExternTypes/Func.php b/src/WebAssembly/Structure/Types/ExternTypes/Func.php
new file mode 100644
index 0000000..d41ed61
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/ExternTypes/Func.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ExternTypes;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ExternType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\FuncType;
+
+final readonly class Func extends ExternType
+{
+    protected function __construct(
+        public FuncType $inner,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Types/ExternTypes/Global_.php b/src/WebAssembly/Structure/Types/ExternTypes/Global_.php
new file mode 100644
index 0000000..1e78370
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/ExternTypes/Global_.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ExternTypes;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ExternType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\GlobalType;
+
+final readonly class Global_ extends ExternType
+{
+    protected function __construct(
+        public GlobalType $inner,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Types/ExternTypes/Mem.php b/src/WebAssembly/Structure/Types/ExternTypes/Mem.php
new file mode 100644
index 0000000..92f1a39
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/ExternTypes/Mem.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ExternTypes;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ExternType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\MemType;
+
+final readonly class Mem extends ExternType
+{
+    protected function __construct(
+        public MemType $inner,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Types/ExternTypes/Table.php b/src/WebAssembly/Structure/Types/ExternTypes/Table.php
new file mode 100644
index 0000000..034d9a8
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/ExternTypes/Table.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ExternTypes;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ExternType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\TableType;
+
+final readonly class Table extends ExternType
+{
+    protected function __construct(
+        public TableType $inner,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Types/FuncType.php b/src/WebAssembly/Structure/Types/FuncType.php
new file mode 100644
index 0000000..6c53519
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/FuncType.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types;
+
+final readonly class FuncType
+{
+    public function __construct(
+        public ResultType $params,
+        public ResultType $results,
+    ) {
+    }
+
+    public function equals(FuncType $other): bool
+    {
+        return $this->params->equals($other->params)
+            && $this->results->equals($other->results);
+    }
+}
diff --git a/src/WebAssembly/Structure/Types/GlobalType.php b/src/WebAssembly/Structure/Types/GlobalType.php
new file mode 100644
index 0000000..3e8ab6c
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/GlobalType.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types;
+
+final readonly class GlobalType
+{
+    public function __construct(
+        public Mut $mut,
+        public ValType $valType,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Types/Limits.php b/src/WebAssembly/Structure/Types/Limits.php
new file mode 100644
index 0000000..e60b842
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/Limits.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types;
+
+final readonly class Limits
+{
+    /**
+     * @param U32 $min
+     * @param ?U32 $max
+     */
+    public function __construct(
+        public int $min,
+        public ?int $max,
+    ) {
+    }
+
+    public function isValid(): bool
+    {
+        return 0 <= $this->min &&
+            ($this->max === null || $this->min <= $this->max);
+    }
+}
diff --git a/src/WebAssembly/Structure/Types/MemType.php b/src/WebAssembly/Structure/Types/MemType.php
new file mode 100644
index 0000000..8d01150
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/MemType.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types;
+
+final readonly class MemType
+{
+    public function __construct(
+        public Limits $limits,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Types/Mut.php b/src/WebAssembly/Structure/Types/Mut.php
new file mode 100644
index 0000000..5bf366c
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/Mut.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types;
+
+enum Mut
+{
+    case Const;
+    case Var;
+}
diff --git a/src/WebAssembly/Structure/Types/NumType.php b/src/WebAssembly/Structure/Types/NumType.php
new file mode 100644
index 0000000..2d5a3b1
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/NumType.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types;
+
+enum NumType
+{
+    case I32;
+    case I64;
+    case F32;
+    case F64;
+}
diff --git a/src/WebAssembly/Structure/Types/RefType.php b/src/WebAssembly/Structure/Types/RefType.php
new file mode 100644
index 0000000..2225f56
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/RefType.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types;
+
+enum RefType
+{
+    case FuncRef;
+    case ExternRef;
+}
diff --git a/src/WebAssembly/Structure/Types/ResultType.php b/src/WebAssembly/Structure/Types/ResultType.php
new file mode 100644
index 0000000..dff2e59
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/ResultType.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types;
+
+use function count;
+
+final readonly class ResultType
+{
+    /**
+     * @param list<ValType> $types
+     */
+    public function __construct(
+        public array $types,
+    ) {
+    }
+
+    public function equals(ResultType $other): bool
+    {
+        if (count($this->types) !== count($other->types)) {
+            return false;
+        }
+        foreach ($this->types as $i => $type) {
+            if (!$type->equals($other->types[$i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/src/WebAssembly/Structure/Types/TableType.php b/src/WebAssembly/Structure/Types/TableType.php
new file mode 100644
index 0000000..7e4b957
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/TableType.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types;
+
+final readonly class TableType
+{
+    public function __construct(
+        public Limits $limits,
+        public RefType $refType,
+    ) {
+    }
+}
diff --git a/src/WebAssembly/Structure/Types/ValType.php b/src/WebAssembly/Structure/Types/ValType.php
new file mode 100644
index 0000000..f6f3111
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/ValType.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types;
+
+abstract readonly class ValType
+{
+    final public static function NumType(NumType $type): ValTypes\NumType
+    {
+        return new ValTypes\NumType($type);
+    }
+
+    final public static function VecType(VecType $type): ValTypes\VecType
+    {
+        return new ValTypes\VecType($type);
+    }
+
+    final public static function RefType(RefType $type): ValTypes\RefType
+    {
+        return new ValTypes\RefType($type);
+    }
+
+    abstract public function equals(ValType $other): bool;
+}
diff --git a/src/WebAssembly/Structure/Types/ValTypes/NumType.php b/src/WebAssembly/Structure/Types/ValTypes/NumType.php
new file mode 100644
index 0000000..1836679
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/ValTypes/NumType.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValTypes;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\NumType as OrigNumType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValType;
+
+final readonly class NumType extends ValType
+{
+    protected function __construct(public OrigNumType $inner)
+    {
+    }
+
+    public function equals(ValType $other): bool
+    {
+        return $other instanceof self
+            && $this->inner === $other->inner;
+    }
+}
diff --git a/src/WebAssembly/Structure/Types/ValTypes/RefType.php b/src/WebAssembly/Structure/Types/ValTypes/RefType.php
new file mode 100644
index 0000000..a31b7c3
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/ValTypes/RefType.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValTypes;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\RefType as OrigRefType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValType;
+
+final readonly class RefType extends ValType
+{
+    protected function __construct(public OrigRefType $inner)
+    {
+    }
+
+    public function equals(ValType $other): bool
+    {
+        return $other instanceof self
+            && $this->inner === $other->inner;
+    }
+}
diff --git a/src/WebAssembly/Structure/Types/ValTypes/VecType.php b/src/WebAssembly/Structure/Types/ValTypes/VecType.php
new file mode 100644
index 0000000..03cc95e
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/ValTypes/VecType.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValTypes;
+
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\ValType;
+use Nsfisis\Waddiwasi\WebAssembly\Structure\Types\VecType as OrigVecType;
+
+final readonly class VecType extends ValType
+{
+    protected function __construct(public OrigVecType $inner)
+    {
+    }
+
+    public function equals(ValType $other): bool
+    {
+        return $other instanceof self
+            && $this->inner === $other->inner; // @phpstan-ignore-line
+    }
+}
diff --git a/src/WebAssembly/Structure/Types/VecType.php b/src/WebAssembly/Structure/Types/VecType.php
new file mode 100644
index 0000000..dcf7d68
--- /dev/null
+++ b/src/WebAssembly/Structure/Types/VecType.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\WebAssembly\Structure\Types;
+
+enum VecType
+{
+    case V128;
+}