From 7d1af849ef7218f827ea2d02c05e49f1d582fb7f Mon Sep 17 00:00:00 2001
From: m3m0r7 <memory.style.serv@gmail.com>
Date: Mon, 25 Dec 2023 19:14:06 +0900
Subject: [PATCH 01/11] Bump ruby 3.3.0

---
 .github/workflows/php.yml                     |  14 +-
 .ruby-version                                 |   1 -
 README.md                                     |   4 +-
 .../HeapSpace/DefaultInstanceHeapSpace.php    |  49 ++
 .../InstructionSequence/CodeLocation.php      |  15 +
 .../InstructionSequence/CodePosition.php      |  15 +
 .../Ruby3_3/InstructionSequence/Insns.php     |  16 +
 .../InstructionSequenceCompileData.php        |  13 +
 .../InstructionSequenceInfo.php               | 124 ++++
 .../InstructionSequenceProcessor.php          | 563 ++++++++++++++++++
 .../Ruby3_3/InstructionSequence/Location.php  |  16 +
 .../InstructionSequence/ObjectParameter.php   |  68 +++
 .../ObjectParameterFlags.php                  |  30 +
 .../Ruby3_3/InstructionSequence/Variable.php  |  15 +
 .../Kernel/Ruby3_3/Internal/Arithmetic.php    |  36 ++
 src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php | 383 ++++++++++++
 .../Ruby3_3/Loader/ArraySymbolLoader.php      |  41 ++
 .../Ruby3_3/Loader/BooleanSymbolLoader.php    |  29 +
 .../Loader/CaseDispatchSymbolLoader.php       |  35 ++
 .../Loader/FixedNumberSymbolLoader.php        |  32 +
 .../Ruby3_3/Loader/FloatSymbolLoader.php      |  35 ++
 .../Kernel/Ruby3_3/Loader/NilSymbolLoader.php |  29 +
 .../Ruby3_3/Loader/RegexpSymbolLoader.php     |  36 ++
 .../Ruby3_3/Loader/StringSymbolLoader.php     |  41 ++
 .../Ruby3_3/Loader/StructSymbolLoader.php     |  56 ++
 .../Ruby3_3/Loader/SymbolSymbolLoader.php     |  41 ++
 .../Verification/VerificationHeader.php       | 129 ++++
 src/VM/Core/Runtime/RubyVM.php                |  16 +-
 tests/Helper/TestApplication.php              |  11 +-
 29 files changed, 1882 insertions(+), 11 deletions(-)
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/HeapSpace/DefaultInstanceHeapSpace.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/CodeLocation.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/CodePosition.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Insns.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceCompileData.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceInfo.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceProcessor.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Location.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/ObjectParameter.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/ObjectParameterFlags.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Variable.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/Internal/Arithmetic.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/ArraySymbolLoader.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/BooleanSymbolLoader.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/CaseDispatchSymbolLoader.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/FixedNumberSymbolLoader.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/FloatSymbolLoader.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/NilSymbolLoader.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/RegexpSymbolLoader.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/StringSymbolLoader.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/StructSymbolLoader.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/SymbolSymbolLoader.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/Verification/VerificationHeader.php

diff --git a/.github/workflows/php.yml b/.github/workflows/php.yml
index aa7cc02b..427458b5 100644
--- a/.github/workflows/php.yml
+++ b/.github/workflows/php.yml
@@ -4,6 +4,9 @@ on: [push]
 jobs:
   lint:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['3.2', '3.3.0-rc1']
     steps:
       - uses: actions/checkout@v3
       - name: Setup PHP
@@ -11,9 +14,9 @@ jobs:
         with:
           php-version: '8.2'
       - name: Setup Ruby
-        uses: ruby/setup-ruby@ec02537da5712d66d4d50a0f33b7eb52773b5ed1
+        uses: ruby/setup-ruby@v1.162.0
         with:
-          ruby-version: '3.2'
+          ruby-version: ${{ matrix.ruby-version }}
       - name: composer cache
         uses: actions/cache@v3
         with:
@@ -32,6 +35,9 @@ jobs:
           ./composer.phar lint:fix
   test:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['3.2', '3.3.0-rc1']
     steps:
       - uses: actions/checkout@v3
       - name: Setup PHP
@@ -39,9 +45,9 @@ jobs:
         with:
           php-version: '8.2'
       - name: Setup Ruby
-        uses: ruby/setup-ruby@ec02537da5712d66d4d50a0f33b7eb52773b5ed1
+        uses: ruby/setup-ruby@v1.162.0
         with:
-          ruby-version: '3.2'
+          ruby-version: ${{ matrix.ruby-version }}
       - name: composer cache
         uses: actions/cache@v3
         with:
diff --git a/.ruby-version b/.ruby-version
index be94e6f5..e69de29b 100644
--- a/.ruby-version
+++ b/.ruby-version
@@ -1 +0,0 @@
-3.2.2
diff --git a/README.md b/README.md
index 355d7355..69c5d151 100644
--- a/README.md
+++ b/README.md
@@ -2,11 +2,11 @@
 
 
 The RubyVM on PHP is implementation RubyVM written in PHP 100%.
-Completely documentation not exists how to implement RubyVM and I was referred [Ruby source code](https://github.com/ruby/ruby) when contributing this project.
+Completely documentation not exists how to implement RubyVM, and I was referred [Ruby source code](https://github.com/ruby/ruby) when contributing this project.
 
 _Notice: This project is very ultra super hyper maximum experimental implementation_
 
-_Notice: I tested Ruby version 3.2 only_
+_Notice: I tested Ruby version 3.2 and 3.3 only_
 
 ### See also
 - https://github.com/ruby/ruby/blob/master/compile.c
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/HeapSpace/DefaultInstanceHeapSpace.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/HeapSpace/DefaultInstanceHeapSpace.php
new file mode 100644
index 00000000..c3497435
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/HeapSpace/DefaultInstanceHeapSpace.php
@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\HeapSpace;
+
+use RubyVM\VM\Core\Runtime\Attribute\BindAliasAs;
+use RubyVM\VM\Core\Runtime\UserlandHeapSpace;
+
+class DefaultInstanceHeapSpace extends UserlandHeapSpace
+{
+    /**
+     * @var array<string>
+     */
+    protected static array $bindClassDirectories = [
+        __DIR__ . '/../../../BasicObject',
+        __DIR__ . '/../../../Entity',
+    ];
+
+    public function __construct()
+    {
+        parent::__construct();
+
+        foreach (self::$bindClassDirectories as $directory) {
+            $this->loadClasses($directory);
+        }
+
+        foreach (get_declared_classes() as $className) {
+            $reflection = new \ReflectionClass($className);
+            foreach ($reflection->getAttributes(BindAliasAs::class) as $attribute) {
+                $this->userlandClasses
+                    ->alias($attribute->getArguments()[0], $className);
+            }
+        }
+    }
+
+    protected function loadClasses(string $directory): void
+    {
+        foreach ((glob("{$directory}/*") ?: []) as $file) {
+            if (is_dir($file)) {
+                $this->loadClasses($file);
+
+                continue;
+            }
+
+            require_once $file;
+        }
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/CodeLocation.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/CodeLocation.php
new file mode 100644
index 00000000..6a545069
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/CodeLocation.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence;
+
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\CodeLocationInterface;
+
+class CodeLocation implements CodeLocationInterface
+{
+    public function __construct(
+        public readonly CodePosition $begin,
+        public readonly CodePosition $end,
+    ) {}
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/CodePosition.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/CodePosition.php
new file mode 100644
index 00000000..8b025420
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/CodePosition.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence;
+
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\CodePositionInterface;
+
+class CodePosition implements CodePositionInterface
+{
+    public function __construct(
+        public readonly int $lineNumber,
+        public readonly int $column,
+    ) {}
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Insns.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Insns.php
new file mode 100644
index 00000000..aea1db80
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Insns.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence;
+
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\InsnsInterface;
+
+class Insns implements InsnsInterface
+{
+    public function __construct(
+        public readonly int $size,
+        public readonly mixed $body,
+        public readonly mixed $positions,
+    ) {}
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceCompileData.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceCompileData.php
new file mode 100644
index 00000000..f6fb7cbe
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceCompileData.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence;
+
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\InstructionSequenceCompileDataInterface;
+
+class InstructionSequenceCompileData implements InstructionSequenceCompileDataInterface
+{
+    public function __construct(
+    ) {}
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceInfo.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceInfo.php
new file mode 100644
index 00000000..22e03e90
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceInfo.php
@@ -0,0 +1,124 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence;
+
+use RubyVM\VM\Core\Runtime\Executor\Operation\OperationEntries;
+use RubyVM\VM\Core\YARV\Criterion\Entry\CallInfoEntries;
+use RubyVM\VM\Core\YARV\Criterion\Entry\CatchEntries;
+use RubyVM\VM\Core\YARV\Criterion\Entry\OuterVariableEntries;
+use RubyVM\VM\Core\YARV\Criterion\Entry\VariableEntries;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\CallInfoInterface;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\InsnsInterface;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\InstructionSequenceInfoInterface;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\InstructionSequenceInterface;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\LocationInterface;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\ObjectParameterInterface;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\VariableInterface;
+use RubyVM\VM\Exception\RubyVMException;
+
+class InstructionSequenceInfo implements InstructionSequenceInfoInterface
+{
+    protected InstructionSequenceCompileData $compileData;
+
+    protected ?CallInfoInterface $currentCallInfo = null;
+
+    public function __construct(
+        private readonly string $path,
+        public readonly int $type,
+        public readonly int $stackMax,
+        public readonly int $iseqSize,
+        public readonly ObjectParameterInterface $objectParam,
+        public readonly int $localTableSize,
+        public readonly int $ciSize,
+        public readonly InsnsInterface $insns,
+        public readonly VariableInterface $variable,
+        public readonly LocationInterface $location,
+        public readonly int $catchExceptP,
+        public readonly int $builtinInlineP,
+        public readonly int $ivcSize,
+        public readonly int $icvArcSize,
+        public readonly int $iseSize,
+        public readonly int $icSize,
+        public readonly OuterVariableEntries $outerVariables,
+        public readonly VariableEntries $variableEntries,
+        public readonly CatchEntries $catchTable,
+        public readonly ?InstructionSequenceInterface $parentISeq,
+        public readonly ?InstructionSequenceInterface $localISeq,
+        public readonly ?InstructionSequenceInterface $mandatoryOnlyISeq,
+        public readonly CallInfoEntries $callInfoEntries,
+        public readonly int $bytecodeOffset,
+        public readonly int $bytecodeSize,
+        private ?OperationEntries $operationEntries = null,
+    ) {
+        $this->compileData = new InstructionSequenceCompileData();
+    }
+
+    public function setOperationEntries(OperationEntries $entries): InstructionSequenceInfoInterface
+    {
+        $this->operationEntries = $entries;
+
+        return $this;
+    }
+
+    public function operationEntries(): OperationEntries
+    {
+        return $this->operationEntries ?? throw new RubyVMException('The operation entry was not set - did you forget to call InstructionSequenceInfo::setOperationSentries before?');
+    }
+
+    public function compileData(): InstructionSequenceCompileData
+    {
+        return $this->compileData;
+    }
+
+    public function type(): int
+    {
+        return $this->type;
+    }
+
+    public function stackMax(): int
+    {
+        return $this->stackMax;
+    }
+
+    public function inlineCacheSize(): int
+    {
+        return $this->icSize;
+    }
+
+    public function parentInstructionSequence(): ?InstructionSequenceInterface
+    {
+        return $this->parentISeq;
+    }
+
+    public function localTableSize(): int
+    {
+        return $this->localTableSize;
+    }
+
+    public function objectParam(): ObjectParameterInterface
+    {
+        return $this->objectParam;
+    }
+
+    public function variables(): VariableEntries
+    {
+        return $this->variableEntries;
+    }
+
+    public function callInfoEntries(): CallInfoEntries
+    {
+        return $this->callInfoEntries;
+    }
+
+    public function catchEntries(): CatchEntries
+    {
+        return $this->catchTable;
+    }
+
+    public function path(): string
+    {
+        return $this->path;
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceProcessor.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceProcessor.php
new file mode 100644
index 00000000..027b704f
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceProcessor.php
@@ -0,0 +1,563 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence;
+
+use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Comparable\Integer_;
+use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Offset;
+use RubyVM\VM\Core\Runtime\ClassCreator;
+use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnType;
+use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
+use RubyVM\VM\Core\Runtime\Executor\Operation\Operation;
+use RubyVM\VM\Core\Runtime\Executor\Operation\OperationEntries;
+use RubyVM\VM\Core\YARV\Criterion\Entry\CallData;
+use RubyVM\VM\Core\YARV\Criterion\Entry\CallInfo;
+use RubyVM\VM\Core\YARV\Criterion\Entry\CallInfoEntries;
+use RubyVM\VM\Core\YARV\Criterion\Entry\Catch_;
+use RubyVM\VM\Core\YARV\Criterion\Entry\CatchEntries;
+use RubyVM\VM\Core\YARV\Criterion\Entry\InsnsBodyEntries;
+use RubyVM\VM\Core\YARV\Criterion\Entry\InsnsPositionEntries;
+use RubyVM\VM\Core\YARV\Criterion\Entry\OuterVariable;
+use RubyVM\VM\Core\YARV\Criterion\Entry\OuterVariableEntries;
+use RubyVM\VM\Core\YARV\Criterion\Entry\Variable as VariableEntry;
+use RubyVM\VM\Core\YARV\Criterion\Entry\VariableEntries;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\Aux\Aux;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\Aux\AuxLoader;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\InstructionSequence;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\InstructionSequenceBody;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\InstructionSequenceBodyInterface;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\InstructionSequenceProcessorInterface;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\Keyword;
+use RubyVM\VM\Core\YARV\Criterion\Offset\Offset as OffsetCriterion;
+use RubyVM\VM\Core\YARV\Essential\ID;
+use RubyVM\VM\Core\YARV\Essential\Symbol\OffsetSymbol;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolInterface;
+use RubyVM\VM\Exception\InstructionSequenceProcessorException;
+
+class InstructionSequenceProcessor implements InstructionSequenceProcessorInterface
+{
+    protected SymbolInterface $path;
+
+    public function __construct(
+        private readonly KernelInterface $kernel,
+        private readonly Aux $aux,
+    ) {
+        if (isset($this->kernel->instructionSequenceList[$this->aux->loader->index])) {
+            return;
+        }
+
+        throw new InstructionSequenceProcessorException(sprintf('Not found instructionSequenceList#%d', $this->aux->loader->index));
+    }
+
+    public function __debugInfo(): array
+    {
+        return [];
+    }
+
+    public function process(): InstructionSequenceBodyInterface
+    {
+        /**
+         * @var OffsetCriterion $offset
+         */
+        $offset = $this->kernel->instructionSequenceList()[$this->aux->loader->index];
+        $this->kernel->stream()->pos($offset->offset);
+
+        $computeFromBodyOffset = static fn (int $x) => $offset->offset - $x;
+
+        $type = $this->kernel->stream()->smallValue();
+        $iseqSize = $this->kernel->stream()->smallValue();
+
+        $bytecodeOffset = $computeFromBodyOffset($this->kernel->stream()->smallValue());
+        $bytecodeSize = $this->kernel->stream()->smallValue();
+
+        $paramFlags = $this->kernel->stream()->smallValue();
+        $paramSize = $this->kernel->stream()->smallValue();
+        $paramLeadNum = $this->kernel->stream()->smallValue();
+        $paramOptNum = $this->kernel->stream()->smallValue();
+        $paramRestStart = $this->kernel->stream()->smallValue();
+        $paramPostStart = $this->kernel->stream()->smallValue();
+        $paramPostNum = $this->kernel->stream()->smallValue();
+        $paramBlockStart = $this->kernel->stream()->smallValue();
+        $paramOptTableOffset = $computeFromBodyOffset($this->kernel->stream()->smallValue());
+        $paramKeywordOffset = $this->kernel->stream()->smallValue();
+        $locationPathObjIndex = $this->kernel->stream()->smallValue();
+        $locationBaseLabelIndex = $this->kernel->stream()->smallValue();
+        $locationLabelIndex = $this->kernel->stream()->smallValue();
+        $locationFirstLineNo = $this->kernel->stream()->smallValue();
+        $locationNodeId = $this->kernel->stream()->smallValue();
+        $locationCodeLocationBegPosLineNo = $this->kernel->stream()->smallValue();
+        $locationCodeLocationBegPosColumn = $this->kernel->stream()->smallValue();
+        $locationCodeLocationEndPosLineNo = $this->kernel->stream()->smallValue();
+        $locationCodeLocationEndPosColumn = $this->kernel->stream()->smallValue();
+        $insnsInfoBodyOffset = $computeFromBodyOffset($this->kernel->stream()->smallValue());
+        $insnsInfoPositionsOffset = $computeFromBodyOffset($this->kernel->stream()->smallValue());
+        $insnsInfoSize = $this->kernel->stream()->smallValue();
+        $localTableOffset = $computeFromBodyOffset($this->kernel->stream()->smallValue());
+        $catchTableSize = $this->kernel->stream()->smallValue();
+        $catchTableOffset = $computeFromBodyOffset($this->kernel->stream()->smallValue());
+        $parentISeqIndex = $this->kernel->stream()->smallValue();
+        $localISeqIndex = $this->kernel->stream()->smallValue();
+        $mandatoryOnlyIseqIndex = $this->kernel->stream()->smallValue();
+        $ciEntriesOffset = $computeFromBodyOffset($v = $this->kernel->stream()->smallValue());
+        $outerVariablesOffset = $computeFromBodyOffset($this->kernel->stream()->smallValue());
+        $variableFlipCount = $this->kernel->stream()->smallValue();
+        $localTableSize = $this->kernel->stream()->smallValue();
+
+        $ivcSize = $this->kernel->stream()->smallValue();
+        $icvArcSize = $this->kernel->stream()->smallValue();
+        $iseSize = $this->kernel->stream()->smallValue();
+        $icSize = $this->kernel->stream()->smallValue();
+        $ciSize = $this->kernel->stream()->smallValue();
+        $stackMax = $this->kernel->stream()->smallValue();
+
+        $catchExceptP = $this->kernel->stream()->smallValue();
+
+        $builtinInlineP = $this->kernel->stream()->smallValue();
+
+        $this->path = $this->kernel->findObject($locationPathObjIndex);
+
+        // see: https://github.com/ruby/ruby/blob/2f603bc4/compile.c#L12298
+        $callInfoEntries = $this->loadCallInfoEntries($ciEntriesOffset, $ciSize);
+        $outerVariables = $this->loadOuterVariables($outerVariablesOffset);
+        $paramOptTable = $this->loadParamOptTable($paramOptTableOffset, $paramOptNum);
+
+        $keyword = $this->loadKeyword($paramKeywordOffset);
+        $insnsBody = $this->loadInsnsBody($insnsInfoBodyOffset, $insnsInfoSize);
+        $insnsPositions = $this->loadInsnsPositions($insnsInfoBodyOffset, $insnsInfoSize);
+        $localTable = $this->loadLocalTable($localTableOffset, $localTableSize);
+        $catchTable = $this->loadCatchTable($catchTableOffset, $catchTableSize);
+
+        $parentISeq = $parentISeqIndex > 0
+            ? new InstructionSequence(
+                aux: $aux = new Aux(
+                    loader: new AuxLoader(
+                        index: $parentISeqIndex,
+                    ),
+                ),
+                processor: new self(
+                    kernel: $this->kernel,
+                    aux: $aux,
+                ),
+            )
+            : null;
+
+        $localISeq = $localISeqIndex > 0
+            ? new InstructionSequence(
+                aux: $aux = new Aux(
+                    loader: new AuxLoader(
+                        index: $localISeqIndex,
+                    ),
+                ),
+                processor: new self(
+                    kernel: $this->kernel,
+                    aux: $aux,
+                ),
+            )
+            : null;
+        $mandatoryOnlyISeq = $mandatoryOnlyIseqIndex > 0
+            ? new InstructionSequence(
+                aux: $aux = new Aux(
+                    loader: new AuxLoader(
+                        index: $mandatoryOnlyIseqIndex,
+                    ),
+                ),
+                processor: new self(
+                    kernel: $this->kernel,
+                    aux: $aux,
+                ),
+            )
+            : null;
+
+        $rbInstructionSequenceBody = new InstructionSequenceInfo(
+            path: $this->path(),
+            type: $type,
+            stackMax: $stackMax,
+            iseqSize: $iseqSize,
+            objectParam: new ObjectParameter(
+                objectParamFlags: new ObjectParameterFlags(
+                    hasLead: (bool) (($paramFlags >> 0) & 1),
+                    hasOpt: (bool) (($paramFlags >> 1) & 1),
+                    hasRest: (bool) (($paramFlags >> 2) & 1),
+                    hasPost: (bool) (($paramFlags >> 3) & 1),
+                    keyword: $keyword,
+                    hasKeyword: (bool) (($paramFlags >> 4) & 1),
+                    hasKeywordRest: (bool) (($paramFlags >> 5) & 1),
+                    hasBlock: (bool) (($paramFlags >> 6) & 1),
+                    ambiguousParam: (bool) (($paramFlags >> 7) & 1),
+                    acceptsNoKeywordArg: (bool) (($paramFlags >> 8) & 1),
+                    ruby2Keywords: (bool) (($paramFlags >> 9) & 1),
+                ),
+                size: $paramSize,
+                leadNum: $paramLeadNum,
+                optNum: $paramOptNum,
+                restStart: $paramRestStart,
+                postStart: $paramPostStart,
+                postNum: $paramPostNum,
+                blockStart: $paramBlockStart,
+                optTable: null, // TODO: Implement here
+            ),
+            localTableSize: $localTableSize,
+            ciSize: $ciSize,
+            insns: new Insns(
+                size: $insnsInfoSize,
+                body: null, // TODO: Implement here
+                positions: null, // TODO: Implement here
+            ),
+            variable: new Variable(
+                flipCount: $variableFlipCount,
+                scriptLines: null, // TODO: Implement here
+            ),
+            location: new Location(
+                firstLineNo: $locationFirstLineNo,
+                nodeId: $locationNodeId,
+                codeLocation: new CodeLocation(
+                    begin: new CodePosition(
+                        lineNumber: $locationCodeLocationBegPosLineNo,
+                        column: $locationCodeLocationBegPosColumn
+                    ),
+                    end: new CodePosition(
+                        lineNumber: $locationCodeLocationEndPosLineNo,
+                        column: $locationCodeLocationEndPosColumn
+                    ),
+                )
+            ),
+            catchExceptP: $catchExceptP,
+            builtinInlineP: $builtinInlineP,
+            ivcSize: $ivcSize,
+            icvArcSize: $icvArcSize,
+            iseSize: $iseSize,
+            icSize: $icSize,
+            outerVariables: $outerVariables,
+            variableEntries: $localTable,
+            catchTable: $catchTable,
+            parentISeq: $parentISeq,
+            localISeq: $localISeq,
+            mandatoryOnlyISeq: $mandatoryOnlyISeq,
+            callInfoEntries: $callInfoEntries,
+            bytecodeOffset: $bytecodeOffset,
+            bytecodeSize: $bytecodeSize,
+        );
+
+        $rbInstructionSequenceBody
+            ->setOperationEntries(
+                $this->loadCode(
+                    bytecodeOffset: $bytecodeOffset,
+                    bytecodeSize: $bytecodeSize,
+                    instructionSequenceSize: $iseqSize,
+                    instructionSequenceBody: $rbInstructionSequenceBody,
+                ),
+            );
+
+        return new InstructionSequenceBody(
+            $rbInstructionSequenceBody,
+        );
+    }
+
+    private function loadCode(
+        int $bytecodeOffset,
+        int $bytecodeSize,
+        int $instructionSequenceSize,
+        InstructionSequenceInfo $instructionSequenceBody,
+    ): OperationEntries {
+        $reader = $this->kernel->stream()->duplication();
+
+        $entries = new OperationEntries();
+        $operationMap = implode('', $this->insnOperationsOperands());
+        $callInfoEntryIndex = 0;
+        $reader->pos($bytecodeOffset);
+
+        for ($codeIndex = 0; $codeIndex < $instructionSequenceSize;) {
+            $insn = Insn::of($insnValue = $reader->smallValue());
+            $entries->append(
+                new Operation(
+                    insn: $insn,
+                )
+            );
+
+            // NOTE: Here is getting operand types for currently opcode
+            $offset = $this->insnOperationOperandsOffsets()[$insnValue];
+            $types = '';
+
+            // Read to null byte
+            for ($i = $offset; $i < strlen($operationMap) && $operationMap[$i] !== "\0"; ++$i) {
+                $types .= $operationMap[$i];
+            }
+
+            ++$codeIndex;
+
+            for ($opIndex = 0; ord($types[$opIndex] ?? "\0"); $opIndex++, $codeIndex++) {
+                $operandType = InsnType::of($types[$opIndex]);
+                $entries->append(
+                    match ($operandType) {
+                        InsnType::TS_VALUE => new Operand(
+                            operand: ClassCreator::createClassBySymbol(
+                                $this->kernel
+                                    ->findObject($reader->smallValue())
+                            ),
+                        ),
+                        InsnType::TS_CALLDATA => new Operand(
+                            operand: $instructionSequenceBody
+                                ->callInfoEntries[$callInfoEntryIndex++],
+                        ),
+
+                        // see: https://github.com/ruby/ruby/blob/ruby_3_2/iseq.c#L2090
+                        InsnType::TS_NUM,
+                        InsnType::TS_LINDEX => new Operand(
+                            operand: Integer_::createBy(
+                                $reader->smallValue(),
+                            )
+                        ),
+
+                        // NOTE: here is not implemented on actually the RubyVM.
+                        // This is originally implemented by the RubyVM on PHP.
+                        InsnType::TS_OFFSET => new Operand(
+                            operand: (new Offset(new OffsetSymbol(
+                                offset: $reader->smallValue(),
+                            ))),
+                        ),
+
+                        InsnType::TS_IC => new Operand(
+                            operand: $this->processInlineCache(
+                                $reader->smallValue()
+                            )
+                        ),
+                        InsnType::TS_ID, InsnType::TS_CDHASH => new Operand(
+                            operand: $this->kernel->findId(
+                                $reader->smallValue(),
+                            ),
+                        ),
+
+                        // Not implemented yet
+                        default => new Operand(
+                            operand: Integer_::createBy($reader->smallValue()),
+                        ),
+                    },
+                );
+            }
+        }
+
+        return $entries;
+    }
+
+    private function loadCallInfoEntries(int $callInfoEntriesOffset, int $callInfoSize): CallInfoEntries
+    {
+        $reader = $this->kernel->stream()->duplication();
+
+        $entries = new CallInfoEntries();
+        $reader->pos($callInfoEntriesOffset);
+        for ($i = 0; $i < $callInfoSize; ++$i) {
+            $midIndex = $reader->smallValue();
+            if ($midIndex === -1) {
+                throw new InstructionSequenceProcessorException(
+                    'Load call info getting unexpected value (mid: -1)',
+                );
+            }
+
+            $mid = $this->kernel->findId($midIndex);
+            $flag = $reader->smallValue();
+            $argc = $reader->smallValue();
+
+            $keywordLength = $reader->smallValue();
+
+            $keywords = null;
+            if ($keywordLength > 0) {
+                $keywords = [];
+                for ($j = 0; $j < $keywordLength; ++$j) {
+                    $keyword = $reader->smallValue();
+                    $keywords[] = $this->kernel
+                        ->findObject($keyword);
+                }
+            }
+
+            $entries->append(
+                new CallInfo(
+                    callData: new CallData(
+                        mid: $mid,
+                        flag: $flag,
+                        argc: $argc,
+
+                        // @phpstan-ignore-next-line
+                        keywords: $keywords,
+                    ),
+                )
+            );
+        }
+
+        return $entries;
+    }
+
+    private function loadOuterVariables(int $outerVariableOffset): OuterVariableEntries
+    {
+        $reader = $this->kernel->stream()->duplication();
+
+        $entries = new OuterVariableEntries();
+        $reader->pos($outerVariableOffset);
+
+        $tableSize = $reader->smallValue();
+
+        for ($i = 0; $i < $tableSize; ++$i) {
+            $key = $this->kernel->findId($reader->smallValue());
+            $value = $reader->smallValue();
+
+            $entries[] = new OuterVariable(
+                $key,
+                $value,
+            );
+        }
+
+        return $entries;
+    }
+
+    private function loadParamOptTable(int $paramOptTableOffset, int $paramOptNum): int
+    {
+        $reader = $this->kernel->stream()->duplication();
+        $reader->pos($paramOptTableOffset);
+
+        // TODO: implement here
+        return -1;
+    }
+
+    private function loadKeyword(int $paramKeywordOffset): Keyword
+    {
+        return new Keyword();
+    }
+
+    private function loadInsnsBody(int $insnsInfoBodyOffset, int $insnsInfoSize): InsnsBodyEntries
+    {
+        return new InsnsBodyEntries();
+    }
+
+    private function loadInsnsPositions(int $insnsInfoBodyOffset, int $insnsInfoSize): InsnsPositionEntries
+    {
+        return new InsnsPositionEntries();
+    }
+
+    private function loadLocalTable(int $localTableOffset, int $localTableSize): VariableEntries
+    {
+        $reader = $this->kernel->stream()->duplication();
+        $entries = new VariableEntries();
+        $reader->pos($localTableOffset);
+
+        for ($i = 0; $i < $localTableSize; ++$i) {
+            // NOTE: only to read 4 bytes
+            $entries[] = new VariableEntry($this->kernel->findId($reader->readAsUnsignedLong()));
+
+            // TODO: You must using longlong but the PHP cannot read longlong value
+            // You will rewrite here to enable to read by longlong
+            $reader->readAsUnsignedLong();
+        }
+
+        return $entries;
+    }
+
+    private function loadCatchTable(int $catchTableOffset, int $catchTableSize): CatchEntries
+    {
+        $reader = $this->kernel->stream()->duplication();
+        $reader->pos($catchTableOffset);
+
+        $entries = new CatchEntries();
+
+        for ($i = 0; $i < $catchTableSize; ++$i) {
+            $entries[] = new Catch_(
+                kernel: $this->kernel,
+                iseqIndex: $reader->smallValue(),
+                type: $reader->smallValue(),
+                start: $reader->smallValue(),
+                end: $reader->smallValue(),
+                cont: $reader->smallValue(),
+                sp: $reader->smallValue(),
+            );
+        }
+
+        return $entries;
+    }
+
+    public function path(): string
+    {
+        return (string) $this->path;
+    }
+
+    private function processInlineCache(int $value): ID
+    {
+        return $this->kernel->findId($value);
+    }
+
+    /**
+     * @return string[]
+     */
+    private function insnOperationsOperands(): array
+    {
+        return [
+            '',     "\0", 'LN',   "\0", 'LN',   "\0", 'LN',   "\0", 'LN',   "\0",
+            'LN',   "\0", 'NN',   "\0", 'N',    "\0", 'IA',   "\0", 'IA',   "\0",
+            'IJ',   "\0", 'IJ',   "\0", 'K',    "\0", 'I',    "\0", 'I',    "\0",
+            'I',    "\0", 'I',    "\0", '',     "\0", '',     "\0", 'V',    "\0",
+            'N',    "\0", 'V',    "\0", 'N',    "\0", '',     "\0", 'NN',   "\0",
+            '',     "\0", 'N',    "\0", 'N',    "\0", 'V',    "\0", 'V',    "\0",
+            'NN',   "\0", '',     "\0", 'V',    "\0", 'N',    "\0", 'N',    "\0",
+            '',     "\0", '',     "\0", 'N',    "\0", '',     "\0", 'N',    "\0",
+            'N',    "\0", 'N',    "\0", 'N',    "\0", 'NVV',  "\0", 'N',    "\0",
+            'LL',   "\0", 'N',    "\0", 'ISN',  "\0", 'IS',   "\0", 'IS',   "\0",
+            'CS',   "\0", 'C',    "\0", 'C',    "\0", 'VC',   "\0", 'C',    "\0",
+            'VC',   "\0", 'N',    "\0", 'N',    "\0", 'CS',   "\0", 'C',    "\0",
+            '',     "\0", 'N',    "\0", 'O',    "\0", 'O',    "\0", 'O',    "\0",
+            'O',    "\0", 'ST',   "\0", 'HO',   "\0", 'C',    "\0", 'C',    "\0",
+            'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'CC',   "\0",
+            'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
+            'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'VC',   "\0",
+            'VC',   "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
+            'C',    "\0", 'C',    "\0", 'R',    "\0", 'RN',   "\0", 'RN',   "\0",
+            'L',    "\0", 'L',    "\0", 'L',    "\0", 'L',    "\0", '',     "\0",
+            '',     "\0", '',     "\0", 'LN',   "\0", 'LN',   "\0", 'LN',   "\0",
+            'LN',   "\0", 'LN',   "\0", 'NN',   "\0", 'N',    "\0", 'IA',   "\0",
+            'IA',   "\0", 'IJ',   "\0", 'IJ',   "\0", 'K',    "\0", 'I',    "\0",
+            'I',    "\0", 'I',    "\0", 'I',    "\0", '',     "\0", '',     "\0",
+            'V',    "\0", 'N',    "\0", 'V',    "\0", 'N',    "\0", '',     "\0",
+            'NN',   "\0", '',     "\0", 'N',    "\0", 'N',    "\0", 'V',    "\0",
+            'V',    "\0", 'NN',   "\0", '',     "\0", 'V',    "\0", 'N',    "\0",
+            'N',    "\0", '',     "\0", '',     "\0", 'N',    "\0", '',     "\0",
+            'N',    "\0", 'N',    "\0", 'N',    "\0", 'N',    "\0", 'NVV',  "\0",
+            'N',    "\0", 'LL',   "\0", 'N',    "\0", 'ISN',  "\0", 'IS',   "\0",
+            'IS',   "\0", 'CS',   "\0", 'C',    "\0", 'C',    "\0", 'VC',   "\0",
+            'C',    "\0", 'VC',   "\0", 'N',    "\0", 'N',    "\0", 'CS',   "\0",
+            'C',    "\0", '',     "\0", 'N',    "\0", 'O',    "\0", 'O',    "\0",
+            'O',    "\0", 'O',    "\0", 'ST',   "\0", 'HO',   "\0", 'C',    "\0",
+            'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
+            'CC',   "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
+            'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
+            'VC',   "\0", 'VC',   "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
+            'C',    "\0", 'C',    "\0", 'C',    "\0", 'R',    "\0", 'RN',   "\0",
+            'RN',   "\0", 'L',    "\0", 'L',    "\0", 'L',    "\0", 'L',    "\0",
+            '',     "\0", '',     "\0",
+        ];
+    }
+
+    /**
+     * @return int[]
+     */
+    private function insnOperationOperandsOffsets(): array
+    {
+        return [
+            0,   1,   4,   7,  10,  13,  16,  19,  21,  24,  27,  30,
+            33,  35,  37,  39,  41,  43,  44,  45,  47,  49,  51,  53,
+            54,  57,  58,  60,  62,  64,  66,  69,  70,  72,  74,  76,
+            77,  78,  80,  81,  83,  85,  87,  89,  93,  95,  98, 100,
+            104, 107, 110, 113, 115, 117, 120, 122, 125, 127, 129, 132,
+            134, 135, 137, 139, 141, 143, 145, 148, 151, 153, 155, 157,
+            159, 161, 163, 166, 168, 170, 172, 174, 176, 178, 180, 182,
+            184, 187, 190, 192, 194, 196, 198, 200, 202, 204, 207, 210,
+            212, 214, 216, 218, 219, 220, 221, 224, 227, 230, 233, 236,
+            239, 241, 244, 247, 250, 253, 255, 257, 259, 261, 263, 264,
+            265, 267, 269, 271, 273, 274, 277, 278, 280, 282, 284, 286,
+            289, 290, 292, 294, 296, 297, 298, 300, 301, 303, 305, 307,
+            309, 313, 315, 318, 320, 324, 327, 330, 333, 335, 337, 340,
+            342, 345, 347, 349, 352, 354, 355, 357, 359, 361, 363, 365,
+            368, 371, 373, 375, 377, 379, 381, 383, 386, 388, 390, 392,
+            394, 396, 398, 400, 402, 404, 407, 410, 412, 414, 416, 418,
+            420, 422, 424, 427, 430, 432, 434, 436, 438, 439,
+        ];
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Location.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Location.php
new file mode 100644
index 00000000..d8b9f8b6
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Location.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence;
+
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\LocationInterface;
+
+class Location implements LocationInterface
+{
+    public function __construct(
+        public readonly int $firstLineNo,
+        public readonly int $nodeId,
+        public readonly CodeLocation $codeLocation,
+    ) {}
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/ObjectParameter.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/ObjectParameter.php
new file mode 100644
index 00000000..5c139023
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/ObjectParameter.php
@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence;
+
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\ObjectParameterFlagsInterface;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\ObjectParameterInterface;
+
+class ObjectParameter implements ObjectParameterInterface
+{
+    public function __construct(
+        public readonly ObjectParameterFlags $objectParamFlags,
+        public readonly int $size,
+        public readonly int $leadNum,
+        public readonly int $optNum,
+        public readonly int $restStart,
+        public readonly int $postStart,
+        public readonly int $postNum,
+        public readonly int $blockStart,
+        public readonly mixed $optTable,
+    ) {}
+
+    public function objectParamFlags(): ObjectParameterFlagsInterface
+    {
+        return $this->objectParamFlags;
+    }
+
+    public function size(): int
+    {
+        return $this->size;
+    }
+
+    public function leadNum(): int
+    {
+        return $this->leadNum;
+    }
+
+    public function optNum(): int
+    {
+        return $this->optNum;
+    }
+
+    public function restStart(): int
+    {
+        return $this->restStart;
+    }
+
+    public function postStart(): int
+    {
+        return $this->postStart;
+    }
+
+    public function postNum(): int
+    {
+        return $this->postNum;
+    }
+
+    public function blockStart(): int
+    {
+        return $this->blockStart;
+    }
+
+    public function optTable(): int
+    {
+        return $this->optTable;
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/ObjectParameterFlags.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/ObjectParameterFlags.php
new file mode 100644
index 00000000..9c66317e
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/ObjectParameterFlags.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence;
+
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\Keyword;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\ObjectParameterFlagsInterface;
+
+class ObjectParameterFlags implements ObjectParameterFlagsInterface
+{
+    public function __construct(
+        public readonly bool $hasLead,
+        public readonly bool $hasOpt,
+        public readonly bool $hasRest,
+        public readonly bool $hasPost,
+        public readonly Keyword $keyword,
+        public readonly bool $hasKeyword,
+        public readonly bool $hasKeywordRest,
+        public readonly bool $hasBlock,
+        public readonly bool $ambiguousParam,
+        public readonly bool $acceptsNoKeywordArg,
+        public readonly bool $ruby2Keywords,
+    ) {}
+
+    public function hasRest(): bool
+    {
+        return $this->hasRest;
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Variable.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Variable.php
new file mode 100644
index 00000000..bb8f3693
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Variable.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence;
+
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\VariableInterface;
+
+class Variable implements VariableInterface
+{
+    public function __construct(
+        public readonly int $flipCount,
+        public readonly mixed $scriptLines,
+    ) {}
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Internal/Arithmetic.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Internal/Arithmetic.php
new file mode 100644
index 00000000..98b82d2f
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Internal/Arithmetic.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Internal;
+
+class Arithmetic
+{
+    final public const RUBY_FIXNUM_FLAG = 0x01;
+
+    public static function isFixNum(int $value): bool
+    {
+        return (bool) ($value & static::RUBY_FIXNUM_FLAG);
+    }
+
+    /**
+     * NOTE: refer INT2FIX implementation.
+     *
+     * @see https://github.com/ruby/ruby/blob/master/include/ruby/internal/arithmetic/long.h
+     */
+    public static function fix2int(int $value): int
+    {
+        return $value >> 1;
+    }
+
+    /**
+     * NOTE: refer INT2FIX implementation.
+     *
+     * @see https://github.com/ruby/ruby/blob/master/include/ruby/internal/arithmetic/long.h
+     */
+    public static function int2fix(int $value): int
+    {
+        // NOTE: Add RUBY_FIXNUM_FLAG
+        return ($value << 1) | static::RUBY_FIXNUM_FLAG;
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php
new file mode 100644
index 00000000..36f3b898
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php
@@ -0,0 +1,383 @@
+<?php
+/**
+ *
+ * $$$$$$$\            $$\                 $$\    $$\ $$\      $$\                                 $$$$$$$\  $$\   $$\ $$$$$$$\
+ * $$  __$$\           $$ |                $$ |   $$ |$$$\    $$$ |                                $$  __$$\ $$ |  $$ |$$  __$$\
+ * $$ |  $$ |$$\   $$\ $$$$$$$\  $$\   $$\ $$ |   $$ |$$$$\  $$$$ |       $$$$$$\  $$$$$$$\        $$ |  $$ |$$ |  $$ |$$ |  $$ |
+ * $$$$$$$  |$$ |  $$ |$$  __$$\ $$ |  $$ |\$$\  $$  |$$\$$\$$ $$ |      $$  __$$\ $$  __$$\       $$$$$$$  |$$$$$$$$ |$$$$$$$  |
+ * $$  __$$< $$ |  $$ |$$ |  $$ |$$ |  $$ | \$$\$$  / $$ \$$$  $$ |      $$ /  $$ |$$ |  $$ |      $$  ____/ $$  __$$ |$$  ____/
+ * $$ |  $$ |$$ |  $$ |$$ |  $$ |$$ |  $$ |  \$$$  /  $$ |\$  /$$ |      $$ |  $$ |$$ |  $$ |      $$ |      $$ |  $$ |$$ |
+ * $$ |  $$ |\$$$$$$  |$$$$$$$  |\$$$$$$$ |   \$  /   $$ | \_/ $$ |      \$$$$$$  |$$ |  $$ |      $$ |      $$ |  $$ |$$ |
+ * \__|  \__| \______/ \_______/  \____$$ |    \_/    \__|     \__|       \______/ \__|  \__|      \__|      \__|  \__|\__|
+ *                               $$\   $$ |
+ *                               \$$$$$$  |
+ *                                \______/
+ */
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3;
+
+use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
+use RubyVM\VM\Core\Runtime\Essential\RubyVMInterface;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\HeapSpace\DefaultInstanceHeapSpace;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence\InstructionSequenceProcessor;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader\ArraySymbolLoader;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader\BooleanSymbolLoader;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader\CaseDispatchSymbolLoader;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader\FixedNumberSymbolLoader;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader\FloatSymbolLoader;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader\NilSymbolLoader;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader\RegexpSymbolLoader;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader\StringSymbolLoader;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader\StructSymbolLoader;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader\SymbolSymbolLoader;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Verification\VerificationHeader;
+use RubyVM\VM\Core\Runtime\Verification\Verifier;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\Aux\Aux;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\Aux\AuxLoader;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\InstructionSequence;
+use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\InstructionSequenceEntries;
+use RubyVM\VM\Core\YARV\Criterion\Offset\Offset;
+use RubyVM\VM\Core\YARV\Criterion\Offset\Offsets;
+use RubyVM\VM\Core\YARV\Criterion\UserlandHeapSpaceInterface;
+use RubyVM\VM\Core\YARV\Essential\ID;
+use RubyVM\VM\Core\YARV\Essential\Symbol\ObjectInfo;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolInterface;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolLoaderInterface;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolType;
+use RubyVM\VM\Core\YARV\RubyVersion;
+use RubyVM\VM\Exception\ResolverException;
+use RubyVM\VM\Exception\RubyVMException;
+use RubyVM\VM\Stream\RubyVMBinaryStreamReader;
+use RubyVM\VM\Stream\RubyVMBinaryStreamReaderInterface;
+
+class Kernel implements KernelInterface
+{
+    public readonly string $magic;
+
+    public readonly int $majorVersion;
+
+    public readonly int $minorVersion;
+
+    public readonly int $size;
+
+    public readonly int $extraSize;
+
+    public readonly int $instructionSequenceListSize;
+
+    public readonly int $globalObjectListSize;
+
+    public readonly int $instructionSequenceListOffset;
+
+    public readonly int $globalObjectListOffset;
+
+    public readonly Offsets $instructionSequenceList;
+
+    public readonly Offsets $globalObjectList;
+
+    protected readonly InstructionSequenceEntries $instructionSequences;
+
+    /**
+     * @var SymbolInterface[]
+     */
+    protected array $globalObjectTable = [];
+
+    public readonly string $rubyPlatform;
+
+    public readonly string $extraData;
+
+    private RubyVMBinaryStreamReaderInterface $stream;
+
+    public function __construct(
+        public readonly RubyVMInterface $vm,
+        public readonly Verifier $verifier,
+    ) {
+        $this->instructionSequenceList = new Offsets();
+        $this->globalObjectList = new Offsets();
+        $this->instructionSequences = new InstructionSequenceEntries();
+    }
+
+    public function __debugInfo(): array
+    {
+        return [];
+    }
+
+    /**
+     * Setup RubyVM.
+     *
+     * @see https://github.com/ruby/ruby/blob/2f603bc4/compile.c#L11087
+     */
+    public function setup(): self
+    {
+        $this->vm->option()->logger->info(
+            'Load an instruction sequence header',
+        );
+        $pos = $this->stream()->pos();
+
+        $this->magic = $this->stream()->read(4);
+        $this->majorVersion = $this->stream()->readAsUnsignedLong();
+        $this->minorVersion = $this->stream()->readAsUnsignedLong();
+        $this->size = $this->stream()->readAsUnsignedLong();
+        $this->extraSize = $this->stream()->readAsUnsignedLong();
+        $this->instructionSequenceListSize = $this->stream()->readAsUnsignedLong();
+        $this->globalObjectListSize = $this->stream()->readAsUnsignedLong();
+        $this->instructionSequenceListOffset = $this->stream()->readAsUnsignedLong();
+        $this->globalObjectListOffset = $this->stream()->readAsUnsignedLong();
+        $this->rubyPlatform = $this->stream()->readAsString();
+
+        $this->vm->option()->logger->info(
+            sprintf('Loaded an instruction sequence header (%d bytes)', $this->stream()->pos() - $pos),
+        );
+
+        $this->setupInstructionSequenceList();
+        $this->setupGlobalObjectList();
+        $this->setupExtraData();
+
+        $this->verifier->verify(
+            new VerificationHeader($this),
+        );
+
+        return $this;
+    }
+
+    /**
+     * Setup instruction sequence offsets.
+     *
+     * @return $this
+     */
+    private function setupInstructionSequenceList(): self
+    {
+        $reader = $this->stream()->duplication();
+        $reader->pos($this->instructionSequenceListOffset);
+
+        $this->vm->option()->logger->info(
+            sprintf('Setup an instruction sequence list (offset: %d)', $this->instructionSequenceListOffset),
+        );
+
+        for ($i = 0; $i < $this->instructionSequenceListSize; ++$i) {
+            $this->instructionSequenceList
+                ->append(
+                    new Offset(
+                        // VALUE iseq_list;       /* [iseq0, ...] */
+                        $reader->readAsUnsignedLong(),
+                    )
+                );
+        }
+
+        $this->vm->option()->logger->info(
+            sprintf('Loaded an instruction sequence list (size: %d)', $reader->pos() - $this->instructionSequenceListOffset),
+        );
+
+        return $this;
+    }
+
+    /**
+     * Setup global object offsets.
+     *
+     * @return $this
+     */
+    private function setupGlobalObjectList(): self
+    {
+        $reader = $this->stream()->duplication();
+        $reader->pos($this->globalObjectListOffset);
+
+        $this->vm->option()->logger->info(
+            sprintf('Setup a global object list (offset: %d)', $this->globalObjectListOffset),
+        );
+
+        for ($i = 0; $i < $this->globalObjectListSize; ++$i) {
+            $this->globalObjectList->append(
+                new Offset(
+                    $reader->readAsUnsignedLong(),
+                )
+            );
+        }
+
+        $this->vm->option()->logger->info(
+            sprintf('Loaded global object list (size: %d)', $reader->pos() - $this->globalObjectListOffset),
+        );
+
+        return $this;
+    }
+
+    public function expectedVersions(): array
+    {
+        return [RubyVersion::VERSION_3_3];
+    }
+
+    public function stream(): RubyVMBinaryStreamReaderInterface
+    {
+        return $this->stream ??= new RubyVMBinaryStreamReader($this->vm->option()->reader);
+    }
+
+    public function findId(int $index): ID
+    {
+        $this->vm->option()->logger->info(
+            sprintf('Start to find object by ID (index: %d)', $index),
+        );
+
+        return new ID($this->findObject($index));
+    }
+
+    public function findObject(int $index): SymbolInterface
+    {
+        if (!isset($this->globalObjectList[$index])) {
+            throw new RubyVMException(sprintf('Cannot resolve to refer index#%d in the global object list', $index));
+        }
+
+        $this->vm->option()->logger->info(
+            sprintf('Start to find object (index: %d)', $index),
+        );
+
+        if (isset($this->globalObjectTable[$index])) {
+            $symbol = $this->globalObjectTable[$index];
+
+            $this->vm->option()->logger->debug(
+                sprintf('Use cached object (index: %d)', $index),
+            );
+
+            return $symbol;
+        }
+
+        $this->vm->option()->logger->debug(
+            sprintf('Start to register new object (index: %d)', $index),
+        );
+
+        /**
+         * @var Offset $offset
+         */
+        $offset = $this->globalObjectList[$index];
+
+        $reader = $this->stream()->duplication();
+        $reader->pos($offset->offset);
+
+        $byte = $reader->readAsUnsignedByte();
+        $info = new ObjectInfo(
+            type: SymbolType::of(($byte >> 0) & 0x1F),
+            specialConst: (bool) ($byte >> 5) & 0x01,
+            frozen: (bool) ($byte >> 6) & 0x01,
+            internal: (bool) ($byte >> 7) & 0x01,
+        );
+
+        $this->vm->option()->logger->info(
+            sprintf(
+                'Loaded an object (index: %d, type: %s, special_const: %d, frozen: %d, internal: %d)',
+                $index,
+                $info->type->name,
+                $info->specialConst,
+                $info->frozen,
+                $info->internal,
+            ),
+        );
+
+        $symbol = $this->resolveLoader($info, $offset->increase())
+            ->load();
+
+        return $this->globalObjectTable[$index] = $symbol;
+    }
+
+    private function resolveLoader(ObjectInfo $info, Offset $offset): SymbolLoaderInterface
+    {
+        return match ($info->type) {
+            SymbolType::NIL => new NilSymbolLoader($this, $offset),
+            SymbolType::STRUCT => new StructSymbolLoader($this, $offset),
+            SymbolType::FALSE,
+            SymbolType::TRUE => new BooleanSymbolLoader($this, $offset),
+            SymbolType::FLOAT => new FloatSymbolLoader($this, $offset),
+            SymbolType::FIXNUM => new FixedNumberSymbolLoader($this, $offset),
+            SymbolType::SYMBOL => new SymbolSymbolLoader($this, $offset),
+            SymbolType::STRING => new StringSymbolLoader($this, $offset),
+            SymbolType::ARRAY => new ArraySymbolLoader($this, $offset),
+            SymbolType::REGEXP => new RegexpSymbolLoader($this, $offset),
+            SymbolType::HASH => new CaseDispatchSymbolLoader($this, $offset),
+            default => throw new ResolverException("Cannot resolve a symbol: {$info->type->name} - maybe the symbol type is not supported yet"),
+        };
+    }
+
+    private function setupExtraData(): void
+    {
+        $reader = $this->stream()->duplication();
+        $reader->pos($this->size);
+
+        $this->extraData = $reader->read($this->extraSize);
+    }
+
+    public function loadInstructionSequence(Aux $aux): InstructionSequence
+    {
+        $instructionSequence = $this
+            ->instructionSequences
+            ->get($aux->loader->index);
+
+        if ($instructionSequence) {
+            return $instructionSequence;
+        }
+
+        // load all sequences
+        for ($i = 0; $i < $this->instructionSequenceListSize; ++$i) {
+            $targetAux = new Aux(
+                loader: new AuxLoader(
+                    $i,
+                ),
+            );
+            $instructionSequence = new InstructionSequence(
+                aux: $targetAux,
+                processor: new InstructionSequenceProcessor(
+                    kernel: $this,
+                    aux: $targetAux,
+                ),
+            );
+
+            $instructionSequence->load();
+
+            $this->instructionSequences->set(
+                $targetAux->loader->index,
+                $instructionSequence,
+            );
+        }
+
+        return $this->loadInstructionSequence($aux);
+    }
+
+    public function rubyPlatform(): string
+    {
+        return $this->rubyPlatform;
+    }
+
+    public function minorVersion(): int
+    {
+        return $this->minorVersion;
+    }
+
+    public function majorVersion(): int
+    {
+        return $this->majorVersion;
+    }
+
+    public function extraData(): string
+    {
+        return $this->extraData;
+    }
+
+    public function userlandHeapSpace(): UserlandHeapSpaceInterface
+    {
+        static $userlandHeapSpace;
+
+        return $userlandHeapSpace ??= new DefaultInstanceHeapSpace();
+    }
+
+    public function instructionSequenceListSize(): int
+    {
+        return $this->instructionSequenceListSize;
+    }
+
+    public function instructionSequenceListOffset(): int
+    {
+        return $this->instructionSequenceListOffset;
+    }
+
+    public function instructionSequenceList(): Offsets
+    {
+        return $this->instructionSequenceList;
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/ArraySymbolLoader.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/ArraySymbolLoader.php
new file mode 100644
index 00000000..da2b3908
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/ArraySymbolLoader.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader;
+
+use RubyVM\VM\Core\Runtime\ClassCreator;
+use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
+use RubyVM\VM\Core\YARV\Criterion\Offset\Offset;
+use RubyVM\VM\Core\YARV\Essential\Symbol\ArraySymbol;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolInterface;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolLoaderInterface;
+
+class ArraySymbolLoader implements SymbolLoaderInterface
+{
+    public function __construct(
+        protected readonly KernelInterface $kernel,
+        protected readonly Offset $offset,
+    ) {}
+
+    public function load(): SymbolInterface
+    {
+        $reader = $this->kernel->stream()->duplication();
+        $reader->pos($this->offset->offset);
+
+        $len = $reader->smallValue();
+        $array = [];
+
+        for ($i = 0; $i < $len; ++$i) {
+            $array[] = ClassCreator::createClassBySymbol(
+                $this->kernel
+                    ->findObject(
+                        $reader
+                            ->smallValue()
+                    ),
+            );
+        }
+
+        return new ArraySymbol($array);
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/BooleanSymbolLoader.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/BooleanSymbolLoader.php
new file mode 100644
index 00000000..04cea69a
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/BooleanSymbolLoader.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader;
+
+use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
+use RubyVM\VM\Core\YARV\Criterion\Offset\Offset;
+use RubyVM\VM\Core\YARV\Essential\Symbol\BooleanSymbol;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolInterface;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolLoaderInterface;
+
+class BooleanSymbolLoader implements SymbolLoaderInterface
+{
+    public function __construct(
+        protected readonly KernelInterface $kernel,
+        protected readonly Offset $offset,
+    ) {}
+
+    public function load(): SymbolInterface
+    {
+        $reader = $this->kernel->stream()->duplication();
+        $reader->pos($this->offset->offset);
+
+        $which = $reader->smallValue();
+
+        return new BooleanSymbol($which !== 0);
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/CaseDispatchSymbolLoader.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/CaseDispatchSymbolLoader.php
new file mode 100644
index 00000000..9699b64f
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/CaseDispatchSymbolLoader.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader;
+
+use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
+use RubyVM\VM\Core\YARV\Criterion\Offset\Offset;
+use RubyVM\VM\Core\YARV\Essential\Symbol\CaseDispatchSymbol;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolInterface;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolLoaderInterface;
+
+class CaseDispatchSymbolLoader implements SymbolLoaderInterface
+{
+    public function __construct(
+        protected readonly KernelInterface $kernel,
+        protected readonly Offset $offset,
+    ) {}
+
+    public function load(): SymbolInterface
+    {
+        $reader = $this->kernel->stream()->duplication();
+        $reader->pos($this->offset->offset);
+
+        $hash = $reader->smallValue();
+        $pos = $reader->smallValue();
+        $len = $reader->smallValue();
+
+        return new CaseDispatchSymbol(
+            $this->kernel->findObject($hash),
+            $pos,
+            $len,
+        );
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/FixedNumberSymbolLoader.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/FixedNumberSymbolLoader.php
new file mode 100644
index 00000000..3bedccf4
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/FixedNumberSymbolLoader.php
@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader;
+
+use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Internal\Arithmetic;
+use RubyVM\VM\Core\YARV\Criterion\Offset\Offset;
+use RubyVM\VM\Core\YARV\Essential\Symbol\NumberSymbol;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolInterface;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolLoaderInterface;
+
+class FixedNumberSymbolLoader implements SymbolLoaderInterface
+{
+    public function __construct(
+        protected readonly KernelInterface $kernel,
+        protected readonly Offset $offset,
+    ) {}
+
+    public function load(): SymbolInterface
+    {
+        $reader = $this->kernel->stream()->duplication();
+        $reader->pos($this->offset->offset);
+
+        $value = $reader->smallValue();
+
+        return new NumberSymbol(
+            Arithmetic::fix2int($value),
+        );
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/FloatSymbolLoader.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/FloatSymbolLoader.php
new file mode 100644
index 00000000..693c2931
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/FloatSymbolLoader.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader;
+
+use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
+use RubyVM\VM\Core\YARV\Criterion\Offset\Offset;
+use RubyVM\VM\Core\YARV\Essential\Symbol\FloatSymbol;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolInterface;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolLoaderInterface;
+use RubyVM\VM\Stream\SizeOf;
+
+class FloatSymbolLoader implements SymbolLoaderInterface
+{
+    public function __construct(
+        protected readonly KernelInterface $kernel,
+        protected readonly Offset $offset,
+    ) {}
+
+    public function load(): SymbolInterface
+    {
+        $reader = $this->kernel->stream()->duplication();
+        $reader->pos(
+            $this->offset
+                ->align(SizeOf::DOUBLE)
+                ->offset
+        );
+        $value = $reader->readAsDouble();
+
+        return new FloatSymbol(
+            $value,
+        );
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/NilSymbolLoader.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/NilSymbolLoader.php
new file mode 100644
index 00000000..ea8a3ef9
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/NilSymbolLoader.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader;
+
+use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
+use RubyVM\VM\Core\YARV\Criterion\Offset\Offset;
+use RubyVM\VM\Core\YARV\Essential\Symbol\NilSymbol;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolInterface;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolLoaderInterface;
+
+class NilSymbolLoader implements SymbolLoaderInterface
+{
+    public function __construct(
+        protected readonly KernelInterface $kernel,
+        protected readonly Offset $offset,
+    ) {}
+
+    public function load(): SymbolInterface
+    {
+        $reader = $this->kernel->stream()->duplication();
+        $reader->pos($this->offset->offset);
+
+        $reader->smallValue();
+
+        return new NilSymbol();
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/RegexpSymbolLoader.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/RegexpSymbolLoader.php
new file mode 100644
index 00000000..70403a9c
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/RegexpSymbolLoader.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader;
+
+use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
+use RubyVM\VM\Core\YARV\Criterion\Offset\Offset;
+use RubyVM\VM\Core\YARV\Essential\Symbol\RegexpSymbol;
+use RubyVM\VM\Core\YARV\Essential\Symbol\StringSymbol;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolInterface;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolLoaderInterface;
+
+class RegexpSymbolLoader implements SymbolLoaderInterface
+{
+    public function __construct(
+        protected readonly KernelInterface $kernel,
+        protected readonly Offset $offset,
+    ) {}
+
+    public function load(): SymbolInterface
+    {
+        $reader = $this->kernel->stream()->duplication();
+        $reader->pos($this->offset->offset);
+
+        $option = $reader->readAsByte();
+        $sourceString = $this->kernel->findObject($reader->smallValue());
+
+        assert($sourceString instanceof StringSymbol);
+
+        return new RegexpSymbol(
+            $sourceString,
+            $option,
+        );
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/StringSymbolLoader.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/StringSymbolLoader.php
new file mode 100644
index 00000000..5fcdb8d3
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/StringSymbolLoader.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader;
+
+use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
+use RubyVM\VM\Core\Runtime\Option;
+use RubyVM\VM\Core\YARV\Criterion\Offset\Offset;
+use RubyVM\VM\Core\YARV\Essential\Encoding;
+use RubyVM\VM\Core\YARV\Essential\Symbol\StringSymbol;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolInterface;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolLoaderInterface;
+use RubyVM\VM\Exception\RubyVMException;
+
+class StringSymbolLoader implements SymbolLoaderInterface
+{
+    public function __construct(
+        protected readonly KernelInterface $kernel,
+        protected readonly Offset $offset,
+    ) {}
+
+    public function load(): SymbolInterface
+    {
+        $reader = $this->kernel->stream()->duplication();
+        $reader->pos($this->offset->offset);
+
+        $encIndex = $reader->smallValue();
+        $len = $reader->smallValue();
+
+        // see: https://github.com/ruby/ruby/blob/2f603bc4/compile.c#L12567
+        if ($encIndex > Option::RUBY_ENCINDEX_BUILTIN_MAX) {
+            throw new RubyVMException('Not implemented yet in encIndex > RUBY_ENCINDEX_BUILTIN_MAX comparison');
+        }
+
+        return new StringSymbol(
+            string: $reader->read($len),
+            encoding: Encoding::of($encIndex),
+        );
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/StructSymbolLoader.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/StructSymbolLoader.php
new file mode 100644
index 00000000..e82f7356
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/StructSymbolLoader.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader;
+
+use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
+use RubyVM\VM\Core\YARV\Criterion\Offset\Offset;
+use RubyVM\VM\Core\YARV\Criterion\Structure\Range;
+use RubyVM\VM\Core\YARV\Essential\Symbol\NilSymbol;
+use RubyVM\VM\Core\YARV\Essential\Symbol\NumberSymbol;
+use RubyVM\VM\Core\YARV\Essential\Symbol\RangeSymbol;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolInterface;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolLoaderInterface;
+use RubyVM\VM\Exception\RubyVMException;
+
+class StructSymbolLoader implements SymbolLoaderInterface
+{
+    public function __construct(
+        protected readonly KernelInterface $kernel,
+        protected readonly Offset $offset,
+    ) {}
+
+    public function load(): SymbolInterface
+    {
+        $reader = $this->kernel->stream()->duplication();
+        $reader->pos(
+            $this
+                ->offset
+                ->align(Range::structure())
+                ->offset,
+        );
+
+        $range = new Range($reader);
+
+        $beginSymbol = $this->kernel
+            ->findObject($range->begin);
+
+        $endSymbol = $this->kernel
+            ->findObject($range->end);
+
+        if (!$beginSymbol instanceof NumberSymbol && !$beginSymbol instanceof NilSymbol) {
+            throw new RubyVMException(sprintf('The StructSymbolLoader expects NumberSymbol at a begin property when creating a range object but actual symbol is %s', $beginSymbol::class));
+        }
+
+        if (!$endSymbol instanceof NumberSymbol && !$endSymbol instanceof NilSymbol) {
+            throw new RubyVMException(sprintf('The StructSymbolLoader expects NumberSymbol at a end property when creating a range object but actual symbol is %s', $endSymbol::class));
+        }
+
+        return new RangeSymbol(
+            begin: $beginSymbol,
+            end: $endSymbol,
+            excludeEnd: 1 === $range->excl,
+        );
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/SymbolSymbolLoader.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/SymbolSymbolLoader.php
new file mode 100644
index 00000000..0bd89ecb
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Loader/SymbolSymbolLoader.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader;
+
+use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
+use RubyVM\VM\Core\Runtime\Option;
+use RubyVM\VM\Core\YARV\Criterion\Offset\Offset;
+use RubyVM\VM\Core\YARV\Essential\Encoding;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolInterface;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolLoaderInterface;
+use RubyVM\VM\Core\YARV\Essential\Symbol\SymbolSymbol;
+use RubyVM\VM\Exception\RubyVMException;
+
+class SymbolSymbolLoader implements SymbolLoaderInterface
+{
+    public function __construct(
+        protected readonly KernelInterface $kernel,
+        protected readonly Offset $offset,
+    ) {}
+
+    public function load(): SymbolInterface
+    {
+        $reader = $this->kernel->stream()->duplication();
+        $reader->pos($this->offset->offset);
+
+        $encIndex = $reader->smallValue();
+        $len = $reader->smallValue();
+
+        // see: https://github.com/ruby/ruby/blob/2f603bc4/compile.c#L12567
+        if ($encIndex > Option::RUBY_ENCINDEX_BUILTIN_MAX) {
+            throw new RubyVMException('Not implemented yet in encIndex > RUBY_ENCINDEX_BUILTIN_MAX comparison');
+        }
+
+        return new SymbolSymbol(
+            string: $reader->read($len),
+            encoding: Encoding::of($encIndex),
+        );
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Verification/VerificationHeader.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Verification/VerificationHeader.php
new file mode 100644
index 00000000..8e30d5e2
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Verification/VerificationHeader.php
@@ -0,0 +1,129 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Verification;
+
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Kernel;
+use RubyVM\VM\Core\Runtime\Verification\VerificationHeaderInterface;
+use RubyVM\VM\Core\Runtime\Verification\VerificationInterface;
+use RubyVM\VM\Exception\VerificationException;
+use RubyVM\VM\Stream\SizeOf;
+
+class VerificationHeader implements VerificationInterface
+{
+    public function __construct(protected readonly Kernel $kernel) {}
+
+    private function verifyMagicByte(): void
+    {
+        if ('YARB' === $this->kernel->magic) {
+            return;
+        }
+
+        $headerBytes = unpack('C*', $this->kernel->magic);
+        if ($headerBytes === false) {
+            throw new VerificationException('The header bytes are invalid');
+        }
+
+        $magicBytes = array_values($headerBytes);
+
+        throw new VerificationException(sprintf('The magic byte is not matched expecting YARB (actual: ' . implode(', ', array_fill(0, count($magicBytes), '0x%02x')) . ')', ...$magicBytes));
+    }
+
+    private function verifyVersion(): void
+    {
+        $actualVersion = "{$this->kernel->majorVersion}.{$this->kernel->minorVersion}";
+        $expectedVersions = [];
+        foreach ($this->kernel->expectedVersions() as $expectedRubyVersion) {
+            $expectedVersion = $expectedRubyVersion->value;
+            if (version_compare(
+                $expectedVersion,
+                $actualVersion,
+                '==',
+            )
+            ) {
+                return;
+            }
+
+            $expectedVersions[] = $expectedVersion;
+        }
+
+        throw new VerificationException(sprintf('The YARB structure is not matched expecting ruby version (expected: [%s], actual: %s)', implode(', ', $expectedVersions), $actualVersion));
+    }
+
+    private function verifyFileSize(): void
+    {
+        $size = $this->kernel->stream()->size();
+        if ($size === null) {
+            throw new VerificationException('The stream size is invalid (size: null)');
+        }
+
+        // NOTE: Append an EOF byte when comparing
+        if ($size !== ($this->kernel->size + $this->kernel->extraSize + 1)) {
+            throw new VerificationException(sprintf('The stream size is invalid (expected: %d, actual: %d)', $this->kernel->size, $size));
+        }
+    }
+
+    private function verifyExtraSize(): void {}
+
+    private function verifyInstructionSequenceListSize(): void
+    {
+        $size = $this->kernel->stream()->size();
+
+        if ($this->kernel->instructionSequenceListSize > $size) {
+            throw new VerificationException('Overflowed the instruction sequence list size. Maybe the YARB structure was broken or unsupported.');
+        }
+    }
+
+    private function verifyGlobalObjectListSize(): void
+    {
+        $size = $this->kernel->stream()->size();
+
+        if ($this->kernel->globalObjectListSize <= $size) {
+            return;
+        }
+
+        throw new VerificationException('Overflowed the global object list size. Maybe the YARB structure was broken or unsupported.');
+    }
+
+    private function verifyInstructionListOffset(): void
+    {
+        $size = $this->kernel->stream()->size();
+
+        if (($this->kernel->instructionSequenceListOffset + $this->kernel->instructionSequenceListSize) <= $size) {
+            return;
+        }
+
+        throw new VerificationException('Overflowed the instruction sequence list offset. Maybe the YARB structure was broken or unsupported.');
+    }
+
+    private function verifyGlobalObjectListOffset(): void
+    {
+        $size = $this->kernel->stream()->size();
+
+        if (($this->kernel->instructionSequenceListOffset + ($this->kernel->instructionSequenceListSize * SizeOf::UNSIGNED_LONG->size())) <= $size) {
+            return;
+        }
+
+        throw new VerificationException('Overflowed the global object list offset. Maybe the YARB structure was broken or unsupported.');
+    }
+
+    public function verify(): bool
+    {
+        $this->verifyMagicByte();
+        $this->verifyVersion();
+        $this->verifyFileSize();
+        $this->verifyExtraSize();
+        $this->verifyGlobalObjectListOffset();
+        $this->verifyGlobalObjectListSize();
+        $this->verifyInstructionSequenceListSize();
+        $this->verifyInstructionListOffset();
+
+        return true;
+    }
+
+    public function verifierName(): string
+    {
+        return VerificationHeaderInterface::class;
+    }
+}
diff --git a/src/VM/Core/Runtime/RubyVM.php b/src/VM/Core/Runtime/RubyVM.php
index 999bed82..0b446624 100644
--- a/src/VM/Core/Runtime/RubyVM.php
+++ b/src/VM/Core/Runtime/RubyVM.php
@@ -15,7 +15,8 @@
 
 class RubyVM implements RubyVMInterface
 {
-    final public const DEFAULT_VERSION = RubyVersion::VERSION_3_2;
+    final public const DEFAULT_VERSION = RubyVersion::VERSION_3_3;
+    protected RubyVersion $specifiedDefaultVersion = self::DEFAULT_VERSION;
 
     /**
      * @var array<string, Runtime>
@@ -29,6 +30,11 @@ public function __construct(public readonly Option $option)
             rubyVersion: RubyVersion::VERSION_3_2,
             kernelClass: \RubyVM\VM\Core\Runtime\Kernel\Ruby3_2\Kernel::class,
         );
+
+        $this->register(
+            rubyVersion: RubyVersion::VERSION_3_3,
+            kernelClass: \RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Kernel::class,
+        );
     }
 
     /**
@@ -64,7 +70,7 @@ public function disassemble(RubyVersion $useVersion = null): ExecutorInterface
             'Start to disassemble instruction sequences',
         );
 
-        $runtime = $this->runtime($useVersion ?? static::DEFAULT_VERSION);
+        $runtime = $this->runtime($useVersion ?? $this->specifiedDefaultVersion);
 
         $kernel = $runtime->kernel()->setup();
 
@@ -113,6 +119,12 @@ public function runtime(RubyVersion $useVersion = null): Runtime
         return $runtime;
     }
 
+    public function setDefaultVersion(RubyVersion $rubyVersion): self
+    {
+        $this->specifiedDefaultVersion = $rubyVersion;
+        return $this;
+    }
+
     public function option(): Option
     {
         return $this->option;
diff --git a/tests/Helper/TestApplication.php b/tests/Helper/TestApplication.php
index bea81f58..08e39a2f 100644
--- a/tests/Helper/TestApplication.php
+++ b/tests/Helper/TestApplication.php
@@ -5,6 +5,7 @@
 namespace Tests\RubyVM\Helper;
 
 use PHPUnit\Framework\TestCase;
+use RubyVM\VM\Core\YARV\RubyVersion;
 use RubyVM\VM\Stream\StreamHandler;
 
 /**
@@ -21,6 +22,8 @@ protected function createRubyVMFromCode(string $code, string $extraData = '', st
             throw new \RuntimeException('tmpfile did not created');
         }
 
+        [$major, $minor, $patch] = sscanf(exec("{$binaryPath} -v"), 'ruby %d.%d.%d');
+
         fwrite($handle, $code);
         $uri = stream_get_meta_data($handle)['uri'];
 
@@ -32,8 +35,8 @@ protected function createRubyVMFromCode(string $code, string $extraData = '', st
         fwrite(
             $compilerHandle,
             <<<_
-        puts RubyVM::InstructionSequence.compile_file("{$uri}").to_binary("{$extraData}")
-        _
+            puts RubyVM::InstructionSequence.compile_file("{$uri}").to_binary("{$extraData}")
+            _
         );
         $compilerRubyUri = stream_get_meta_data($compilerHandle)['uri'];
 
@@ -58,6 +61,10 @@ protected function createRubyVMFromCode(string $code, string $extraData = '', st
             ),
         );
 
+        $rubyVM->setDefaultVersion(
+            RubyVersion::from("{$major}.{$minor}"),
+        );
+
         return new RubyVMManager(
             $rubyVM,
             $stdOut,

From ec080432121192dcdd3dd93ee930b4b6db393a77 Mon Sep 17 00:00:00 2001
From: m3m0r7 <memory.style.serv@gmail.com>
Date: Mon, 25 Dec 2023 19:18:46 +0900
Subject: [PATCH 02/11] Remove specified versions in tests

---
 .../Kernel/Object_/Comparable/IntegerTest.php |  6 ++---
 .../Kernel/Object_/Comparable/StringTest.php  |  4 ++--
 .../Kernel/Object_/Enumerable/ArrayTest.php   | 10 ++++----
 .../Kernel/Object_/Enumerable/RangeTest.php   |  4 ++--
 .../Call/Logic/Complex/FibonacciTest.php      |  2 +-
 .../Call/Logic/Complex/FizzBuzzTest.php       |  2 +-
 .../Call/Logic/Complex/QuicksortTest.php      |  2 +-
 tests/Version/RubyVM/Call/Method/ExitTest.php |  2 +-
 .../RubyVM/Call/Method/InspectionTest.php     | 14 +++++------
 .../Version/RubyVM/Call/Method/MethodTest.php | 10 ++++----
 tests/Version/RubyVM/Call/Method/NilTest.php  |  2 +-
 tests/Version/RubyVM/Call/Method/PTest.php    |  4 ++--
 tests/Version/RubyVM/Call/Method/ProcTest.php | 10 ++++----
 .../Version/RubyVM/Call/Method/ToIntTest.php  |  2 +-
 .../RubyVM/Call/Method/ToStringTest.php       |  2 +-
 .../RubyVM/Call/PHP/CallRubyMethodsTest.php   |  4 ++--
 .../RubyVM/GenericSyntax/ArithmeticTest.php   | 24 +++++++++----------
 .../RubyVM/GenericSyntax/BlockTest.php        |  8 +++----
 .../RubyVM/GenericSyntax/BooleanTest.php      | 10 ++++----
 .../RubyVM/GenericSyntax/CaseWhenTest.php     |  6 ++---
 .../GenericSyntax/Class/DefineClassTest.php   |  2 +-
 .../Class/DefineMethodInClassTest.php         |  4 ++--
 .../Class/DefineStaticMethodTest.php          |  4 ++--
 .../GenericSyntax/Class/ExtendedClassTest.php |  6 ++---
 .../Class/InstanceVariableTest.php            |  4 ++--
 .../RubyVM/GenericSyntax/ComparableTest.php   |  8 +++----
 .../RubyVM/GenericSyntax/ConcatTest.php       | 10 ++++----
 .../RubyVM/GenericSyntax/DefinedTest.php      |  8 +++----
 .../GenericSyntax/GlobalVariableTest.php      |  2 +-
 .../Version/RubyVM/GenericSyntax/HashTest.php |  2 +-
 .../GenericSyntax/KeywordArgumentsTest.php    |  2 +-
 .../GenericSyntax/LocalVariableTest.php       |  4 ++--
 .../RubyVM/GenericSyntax/Method/BlockTest.php |  4 ++--
 .../GenericSyntax/Method/DefineMethodTest.php |  8 +++----
 .../GenericSyntax/NegativeValueTest.php       |  2 +-
 .../RubyVM/GenericSyntax/RaiseTest.php        |  2 +-
 .../RubyVM/GenericSyntax/RegexpTest.php       |  6 ++---
 .../RubyVM/GenericSyntax/RescueTest.php       |  4 ++--
 .../RubyVM/GenericSyntax/SymbolTest.php       |  2 +-
 .../RubyVM/GenericSyntax/VariadicTest.php     |  2 +-
 40 files changed, 107 insertions(+), 107 deletions(-)

diff --git a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/IntegerTest.php b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/IntegerTest.php
index 02df7fa1..61b2c683 100644
--- a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/IntegerTest.php
+++ b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/IntegerTest.php
@@ -26,7 +26,7 @@ public function testEven(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -47,7 +47,7 @@ public function testOdd(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -68,7 +68,7 @@ public function testZero(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/StringTest.php b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/StringTest.php
index d128da91..78c43f9b 100644
--- a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/StringTest.php
+++ b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/StringTest.php
@@ -26,7 +26,7 @@ public function testEmpty(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -47,7 +47,7 @@ public function testInclude(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/ArrayTest.php b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/ArrayTest.php
index 269ad406..d6633f74 100644
--- a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/ArrayTest.php
+++ b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/ArrayTest.php
@@ -27,7 +27,7 @@ public function testStringArray(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -52,7 +52,7 @@ public function testForStatementWithLocalVariable(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -77,7 +77,7 @@ public function testForStatementWithLocalVariableAnotherSyntax(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -104,7 +104,7 @@ public function testShowArrayInMethod(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -126,7 +126,7 @@ public function testShowArrayInMethod(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/RangeTest.php b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/RangeTest.php
index a5c4e24a..81a141e0 100644
--- a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/RangeTest.php
+++ b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/RangeTest.php
@@ -31,7 +31,7 @@ public function testCallEachBlockNonExcludedAndExcluded(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -58,7 +58,7 @@ public function testInfinityRange(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/Call/Logic/Complex/FibonacciTest.php b/tests/Version/RubyVM/Call/Logic/Complex/FibonacciTest.php
index 26cd8b36..023f03a6 100644
--- a/tests/Version/RubyVM/Call/Logic/Complex/FibonacciTest.php
+++ b/tests/Version/RubyVM/Call/Logic/Complex/FibonacciTest.php
@@ -37,7 +37,7 @@ public function testFibonacci(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/Call/Logic/Complex/FizzBuzzTest.php b/tests/Version/RubyVM/Call/Logic/Complex/FizzBuzzTest.php
index fd2d6464..6ce5c1a2 100644
--- a/tests/Version/RubyVM/Call/Logic/Complex/FizzBuzzTest.php
+++ b/tests/Version/RubyVM/Call/Logic/Complex/FizzBuzzTest.php
@@ -35,7 +35,7 @@ public function testFizzBuzz(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/Call/Logic/Complex/QuicksortTest.php b/tests/Version/RubyVM/Call/Logic/Complex/QuicksortTest.php
index 5da98489..237f2cdc 100644
--- a/tests/Version/RubyVM/Call/Logic/Complex/QuicksortTest.php
+++ b/tests/Version/RubyVM/Call/Logic/Complex/QuicksortTest.php
@@ -43,7 +43,7 @@ public function testQuickSort(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/Call/Method/ExitTest.php b/tests/Version/RubyVM/Call/Method/ExitTest.php
index 6b105e27..4f4bedd5 100644
--- a/tests/Version/RubyVM/Call/Method/ExitTest.php
+++ b/tests/Version/RubyVM/Call/Method/ExitTest.php
@@ -26,7 +26,7 @@ public function testExit(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $executor->execute();
     }
diff --git a/tests/Version/RubyVM/Call/Method/InspectionTest.php b/tests/Version/RubyVM/Call/Method/InspectionTest.php
index 703d61ed..f6853ccd 100644
--- a/tests/Version/RubyVM/Call/Method/InspectionTest.php
+++ b/tests/Version/RubyVM/Call/Method/InspectionTest.php
@@ -25,7 +25,7 @@ public function testCallInspectionOnArray(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("[5, 4, 3, 2, 1]\n", $rubyVMManager->stdOut->readAll());
@@ -41,7 +41,7 @@ public function testCallInspectionOnString(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("\"Hello World!\"\n", $rubyVMManager->stdOut->readAll());
@@ -57,7 +57,7 @@ public function testCallInspectionOnNumber(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("1234\n", $rubyVMManager->stdOut->readAll());
@@ -73,7 +73,7 @@ public function testCallInspectionOnFloat(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("1.5\n", $rubyVMManager->stdOut->readAll());
@@ -90,7 +90,7 @@ public function testCallInspectionOnBoolean(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("true\nfalse\n", $rubyVMManager->stdOut->readAll());
@@ -106,7 +106,7 @@ public function testCallInspectionOnNil(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("nil\n", $rubyVMManager->stdOut->readAll());
@@ -123,7 +123,7 @@ public function testCallInspectionOnRange(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("1..5\n1...5\n", $rubyVMManager->stdOut->readAll());
diff --git a/tests/Version/RubyVM/Call/Method/MethodTest.php b/tests/Version/RubyVM/Call/Method/MethodTest.php
index b9f58362..f44fd5db 100644
--- a/tests/Version/RubyVM/Call/Method/MethodTest.php
+++ b/tests/Version/RubyVM/Call/Method/MethodTest.php
@@ -25,7 +25,7 @@ public function testPutsMethod(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("HelloWorld!\n", $rubyVMManager->stdOut->readAll());
@@ -41,7 +41,7 @@ public function testPHPInfoMethod(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $version = PHP_VERSION;
@@ -62,7 +62,7 @@ public function testXOR(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("7\n", $rubyVMManager->stdOut->readAll());
@@ -78,7 +78,7 @@ public function testPower(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("32\n", $rubyVMManager->stdOut->readAll());
@@ -94,7 +94,7 @@ public function testRightShift(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("1\n", $rubyVMManager->stdOut->readAll());
diff --git a/tests/Version/RubyVM/Call/Method/NilTest.php b/tests/Version/RubyVM/Call/Method/NilTest.php
index 308c1f0c..97ebe5c4 100644
--- a/tests/Version/RubyVM/Call/Method/NilTest.php
+++ b/tests/Version/RubyVM/Call/Method/NilTest.php
@@ -31,7 +31,7 @@ public function testObjectIsNil(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/Call/Method/PTest.php b/tests/Version/RubyVM/Call/Method/PTest.php
index 745867b0..53e99b8a 100644
--- a/tests/Version/RubyVM/Call/Method/PTest.php
+++ b/tests/Version/RubyVM/Call/Method/PTest.php
@@ -30,7 +30,7 @@ public function testSimpleP(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -54,7 +54,7 @@ public function testDefaultClassP(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertMatchesRegularExpression(
diff --git a/tests/Version/RubyVM/Call/Method/ProcTest.php b/tests/Version/RubyVM/Call/Method/ProcTest.php
index ee0655af..d1f61c39 100644
--- a/tests/Version/RubyVM/Call/Method/ProcTest.php
+++ b/tests/Version/RubyVM/Call/Method/ProcTest.php
@@ -26,7 +26,7 @@ public function testProc(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("Hello World!\n", $rubyVMManager->stdOut->readAll());
@@ -47,7 +47,7 @@ public function testComplexProc(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("Hello World!\n", $rubyVMManager->stdOut->readAll());
@@ -67,7 +67,7 @@ public function testNonArgumentsProc(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("Hello World!\n", $rubyVMManager->stdOut->readAll());
@@ -84,7 +84,7 @@ public function testProcWithNewChainedCall(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("\"Hello World!\"\n", $rubyVMManager->stdOut->readAll());
@@ -101,7 +101,7 @@ public function testProcWithNewNestedNew(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("\"Hello World!\"\n", $rubyVMManager->stdOut->readAll());
diff --git a/tests/Version/RubyVM/Call/Method/ToIntTest.php b/tests/Version/RubyVM/Call/Method/ToIntTest.php
index 5a03d37d..65d780c1 100644
--- a/tests/Version/RubyVM/Call/Method/ToIntTest.php
+++ b/tests/Version/RubyVM/Call/Method/ToIntTest.php
@@ -25,7 +25,7 @@ public function testToInt(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("65535\n", $rubyVMManager->stdOut->readAll());
diff --git a/tests/Version/RubyVM/Call/Method/ToStringTest.php b/tests/Version/RubyVM/Call/Method/ToStringTest.php
index ef51b2e7..7adf75d4 100644
--- a/tests/Version/RubyVM/Call/Method/ToStringTest.php
+++ b/tests/Version/RubyVM/Call/Method/ToStringTest.php
@@ -25,7 +25,7 @@ public function testToString(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("65535\n", $rubyVMManager->stdOut->readAll());
diff --git a/tests/Version/RubyVM/Call/PHP/CallRubyMethodsTest.php b/tests/Version/RubyVM/Call/PHP/CallRubyMethodsTest.php
index 3fb1788e..8d4d0ae4 100644
--- a/tests/Version/RubyVM/Call/PHP/CallRubyMethodsTest.php
+++ b/tests/Version/RubyVM/Call/PHP/CallRubyMethodsTest.php
@@ -27,7 +27,7 @@ public function testCallUserlandMethodWithoutArgumentsFromPHP(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $executed = $executor->execute();
         $this->assertSame(ExecutedStatus::SUCCESS, $executed->executedStatus);
@@ -64,7 +64,7 @@ public function testCallUserlandMethodFromPHP(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $executed = $executor->execute();
         $this->assertSame(ExecutedStatus::SUCCESS, $executed->executedStatus);
diff --git a/tests/Version/RubyVM/GenericSyntax/ArithmeticTest.php b/tests/Version/RubyVM/GenericSyntax/ArithmeticTest.php
index 4e00f3e7..c433ca5b 100644
--- a/tests/Version/RubyVM/GenericSyntax/ArithmeticTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/ArithmeticTest.php
@@ -25,7 +25,7 @@ public function testNumberPlusNumber(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("6\n", $rubyVMManager->stdOut->readAll());
@@ -41,7 +41,7 @@ public function testNumberMinusNumber(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("-4\n", $rubyVMManager->stdOut->readAll());
@@ -57,7 +57,7 @@ public function testNumberMultiplyNumber(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("64\n", $rubyVMManager->stdOut->readAll());
@@ -73,7 +73,7 @@ public function testNumberDivideNumber(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("1\n", $rubyVMManager->stdOut->readAll());
@@ -89,7 +89,7 @@ public function testFloatPlusFloat(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("6.0\n", $rubyVMManager->stdOut->readAll());
@@ -105,7 +105,7 @@ public function testFloatMinusFloat(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("-4.0\n", $rubyVMManager->stdOut->readAll());
@@ -121,7 +121,7 @@ public function testFloatMultiplyFloat(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("64.0\n", $rubyVMManager->stdOut->readAll());
@@ -137,7 +137,7 @@ public function testFloatDivideFloat(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("1.3333333333333333\n", $rubyVMManager->stdOut->readAll());
@@ -153,7 +153,7 @@ public function testMod(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("3\n", $rubyVMManager->stdOut->readAll());
@@ -169,7 +169,7 @@ public function testAnd(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("1\n", $rubyVMManager->stdOut->readAll());
@@ -185,7 +185,7 @@ public function testOr(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("3\n", $rubyVMManager->stdOut->readAll());
@@ -201,7 +201,7 @@ public function testLeftShift(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("4\n", $rubyVMManager->stdOut->readAll());
diff --git a/tests/Version/RubyVM/GenericSyntax/BlockTest.php b/tests/Version/RubyVM/GenericSyntax/BlockTest.php
index dae5d44f..bd8a8ee6 100644
--- a/tests/Version/RubyVM/GenericSyntax/BlockTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/BlockTest.php
@@ -36,7 +36,7 @@ public function testBlock(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("1st Hello World!\n2nd Hello World!\n", $rubyVMManager->stdOut->readAll());
@@ -63,7 +63,7 @@ public function testBlockWithVariables(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("1st Hello World!\n2nd Hello World!\n", $rubyVMManager->stdOut->readAll());
@@ -92,7 +92,7 @@ public function testBlockWithVariablesWithOutsideVariable(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("1st Hello World! with outside\n2nd Hello World! with outside\n", $rubyVMManager->stdOut->readAll());
@@ -124,7 +124,7 @@ public function testBlockComplexVariables(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("1st Hello World! with outside ! :)\n2nd Hello World! with outside ! :)\n", $rubyVMManager->stdOut->readAll());
diff --git a/tests/Version/RubyVM/GenericSyntax/BooleanTest.php b/tests/Version/RubyVM/GenericSyntax/BooleanTest.php
index bdfd880d..18e53485 100644
--- a/tests/Version/RubyVM/GenericSyntax/BooleanTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/BooleanTest.php
@@ -25,7 +25,7 @@ public function testTrueAndFalse(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("false\n", $rubyVMManager->stdOut->readAll());
@@ -41,7 +41,7 @@ public function testTrueOrFalse(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("true\n", $rubyVMManager->stdOut->readAll());
@@ -57,7 +57,7 @@ public function testTrueAndTrue(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("true\n", $rubyVMManager->stdOut->readAll());
@@ -76,7 +76,7 @@ public function testMultiBoolean(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("true\n", $rubyVMManager->stdOut->readAll());
@@ -108,7 +108,7 @@ public function testManyLocalVariables(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("true\n", $rubyVMManager->stdOut->readAll());
diff --git a/tests/Version/RubyVM/GenericSyntax/CaseWhenTest.php b/tests/Version/RubyVM/GenericSyntax/CaseWhenTest.php
index d68f57c5..9ecaa850 100644
--- a/tests/Version/RubyVM/GenericSyntax/CaseWhenTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/CaseWhenTest.php
@@ -35,7 +35,7 @@ public function testCase(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -64,7 +64,7 @@ public function testCaseToElse(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -93,7 +93,7 @@ public function testCaseToNonElse(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/GenericSyntax/Class/DefineClassTest.php b/tests/Version/RubyVM/GenericSyntax/Class/DefineClassTest.php
index 36497af6..3c1c08ba 100644
--- a/tests/Version/RubyVM/GenericSyntax/Class/DefineClassTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/Class/DefineClassTest.php
@@ -31,7 +31,7 @@ class Test
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("Hello World!\n", $rubyVMManager->stdOut->readAll());
diff --git a/tests/Version/RubyVM/GenericSyntax/Class/DefineMethodInClassTest.php b/tests/Version/RubyVM/GenericSyntax/Class/DefineMethodInClassTest.php
index 001ede1a..3aeb6496 100644
--- a/tests/Version/RubyVM/GenericSyntax/Class/DefineMethodInClassTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/Class/DefineMethodInClassTest.php
@@ -34,7 +34,7 @@ class Animal
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<< '_'
@@ -64,7 +64,7 @@ class << self
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<< '_'
diff --git a/tests/Version/RubyVM/GenericSyntax/Class/DefineStaticMethodTest.php b/tests/Version/RubyVM/GenericSyntax/Class/DefineStaticMethodTest.php
index 5e6213fc..1c0390db 100644
--- a/tests/Version/RubyVM/GenericSyntax/Class/DefineStaticMethodTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/Class/DefineStaticMethodTest.php
@@ -37,7 +37,7 @@ class << self
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<< '_'
@@ -74,7 +74,7 @@ class << self
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<< '_'
diff --git a/tests/Version/RubyVM/GenericSyntax/Class/ExtendedClassTest.php b/tests/Version/RubyVM/GenericSyntax/Class/ExtendedClassTest.php
index c7d01963..e091e0a2 100644
--- a/tests/Version/RubyVM/GenericSyntax/Class/ExtendedClassTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/Class/ExtendedClassTest.php
@@ -39,7 +39,7 @@ class Array
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<< '_'
@@ -67,7 +67,7 @@ class Integer
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<< '_'
@@ -95,7 +95,7 @@ class Integer
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<< '_'
diff --git a/tests/Version/RubyVM/GenericSyntax/Class/InstanceVariableTest.php b/tests/Version/RubyVM/GenericSyntax/Class/InstanceVariableTest.php
index 818b5ebf..1660dcba 100644
--- a/tests/Version/RubyVM/GenericSyntax/Class/InstanceVariableTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/Class/InstanceVariableTest.php
@@ -37,7 +37,7 @@ class Test
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<< '_'
@@ -75,7 +75,7 @@ class Array
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<< '_'
diff --git a/tests/Version/RubyVM/GenericSyntax/ComparableTest.php b/tests/Version/RubyVM/GenericSyntax/ComparableTest.php
index 809894a3..53c021aa 100644
--- a/tests/Version/RubyVM/GenericSyntax/ComparableTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/ComparableTest.php
@@ -27,7 +27,7 @@ public function testCompareLessThan(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -50,7 +50,7 @@ public function testCompareLessOrEqualsThan(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -73,7 +73,7 @@ public function testCompareGreaterThan(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -96,7 +96,7 @@ public function testCompareGreaterOrEqualsThan(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/GenericSyntax/ConcatTest.php b/tests/Version/RubyVM/GenericSyntax/ConcatTest.php
index ce8f9706..9df9f86b 100644
--- a/tests/Version/RubyVM/GenericSyntax/ConcatTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/ConcatTest.php
@@ -25,7 +25,7 @@ public function testConcatString(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("HelloWorld!\n", $rubyVMManager->stdOut->readAll());
@@ -41,7 +41,7 @@ public function testStringPlusNumber(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("HelloWorld65535\n", $rubyVMManager->stdOut->readAll());
@@ -58,7 +58,7 @@ public function testConcatArray(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("[1, 2, 3, 4, 5, 6]\n", $rubyVMManager->stdOut->readAll());
@@ -77,7 +77,7 @@ public function testSplatArrayWithVariables(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -101,7 +101,7 @@ public function testSplatArrayInMethod(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/GenericSyntax/DefinedTest.php b/tests/Version/RubyVM/GenericSyntax/DefinedTest.php
index 14498500..99576c84 100644
--- a/tests/Version/RubyVM/GenericSyntax/DefinedTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/DefinedTest.php
@@ -26,7 +26,7 @@ public function testDefinedVariable(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("\"local-variable\"\n", $rubyVMManager->stdOut->readAll());
@@ -43,7 +43,7 @@ public function testDefinedGlobalVariable(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("\"global-variable\"\n", $rubyVMManager->stdOut->readAll());
@@ -61,7 +61,7 @@ public function testDefinedMethod(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("\"method\"\n", $rubyVMManager->stdOut->readAll());
@@ -79,7 +79,7 @@ class Var
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("\"constant\"\n", $rubyVMManager->stdOut->readAll());
diff --git a/tests/Version/RubyVM/GenericSyntax/GlobalVariableTest.php b/tests/Version/RubyVM/GenericSyntax/GlobalVariableTest.php
index f4999e21..acdce1c7 100644
--- a/tests/Version/RubyVM/GenericSyntax/GlobalVariableTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/GlobalVariableTest.php
@@ -27,7 +27,7 @@ public function testGlobalVariable(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/GenericSyntax/HashTest.php b/tests/Version/RubyVM/GenericSyntax/HashTest.php
index 04681eac..4c869f88 100644
--- a/tests/Version/RubyVM/GenericSyntax/HashTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/HashTest.php
@@ -30,7 +30,7 @@ public function testHash(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/GenericSyntax/KeywordArgumentsTest.php b/tests/Version/RubyVM/GenericSyntax/KeywordArgumentsTest.php
index 5a352c4f..da2b0446 100644
--- a/tests/Version/RubyVM/GenericSyntax/KeywordArgumentsTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/KeywordArgumentsTest.php
@@ -31,7 +31,7 @@ public function testKeywordArguments(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("tanuki\ninu\nneko\n", $rubyVMManager->stdOut->readAll());
diff --git a/tests/Version/RubyVM/GenericSyntax/LocalVariableTest.php b/tests/Version/RubyVM/GenericSyntax/LocalVariableTest.php
index bd62c27a..5fbb94d7 100644
--- a/tests/Version/RubyVM/GenericSyntax/LocalVariableTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/LocalVariableTest.php
@@ -27,7 +27,7 @@ public function testLocalVariable(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("25\n", $rubyVMManager->stdOut->readAll());
@@ -59,7 +59,7 @@ public function testInternalEnvIndexTest(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/GenericSyntax/Method/BlockTest.php b/tests/Version/RubyVM/GenericSyntax/Method/BlockTest.php
index 731ebb4d..dc73f88c 100644
--- a/tests/Version/RubyVM/GenericSyntax/Method/BlockTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/Method/BlockTest.php
@@ -31,7 +31,7 @@ public function testCallBlock(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -60,7 +60,7 @@ public function testCallDuplicatedBlock(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/GenericSyntax/Method/DefineMethodTest.php b/tests/Version/RubyVM/GenericSyntax/Method/DefineMethodTest.php
index 04286d65..5c84f398 100644
--- a/tests/Version/RubyVM/GenericSyntax/Method/DefineMethodTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/Method/DefineMethodTest.php
@@ -28,7 +28,7 @@ public function testDefineMethod(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("65535\n", $rubyVMManager->stdOut->readAll());
@@ -51,7 +51,7 @@ public function testLocalVarAllOptionalAndAssignedParameters(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -80,7 +80,7 @@ public function testLocalVarAllOptionalAndOmittedParameters(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -117,7 +117,7 @@ public function testComplexLocalVarPattern(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/GenericSyntax/NegativeValueTest.php b/tests/Version/RubyVM/GenericSyntax/NegativeValueTest.php
index 9a61e8ee..615d0bed 100644
--- a/tests/Version/RubyVM/GenericSyntax/NegativeValueTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/NegativeValueTest.php
@@ -32,7 +32,7 @@ public function testNegativeValue(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/GenericSyntax/RaiseTest.php b/tests/Version/RubyVM/GenericSyntax/RaiseTest.php
index 0ff5ba84..9425a209 100644
--- a/tests/Version/RubyVM/GenericSyntax/RaiseTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/RaiseTest.php
@@ -26,7 +26,7 @@ public function testRaise(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $result = $executor->execute();
         $this->assertSame(ExecutedStatus::EXIT, $result->executedStatus);
diff --git a/tests/Version/RubyVM/GenericSyntax/RegexpTest.php b/tests/Version/RubyVM/GenericSyntax/RegexpTest.php
index 5b0f848e..93746a5a 100644
--- a/tests/Version/RubyVM/GenericSyntax/RegexpTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/RegexpTest.php
@@ -30,7 +30,7 @@ public function testRegExpWithMatched(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -54,7 +54,7 @@ public function testRegExpWithUnmatched(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -85,7 +85,7 @@ public function testContinuingRegExp(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/GenericSyntax/RescueTest.php b/tests/Version/RubyVM/GenericSyntax/RescueTest.php
index d6025d46..72b98105 100644
--- a/tests/Version/RubyVM/GenericSyntax/RescueTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/RescueTest.php
@@ -29,7 +29,7 @@ public function testSimpleCatch(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
@@ -56,7 +56,7 @@ public function testNestedCatch(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/GenericSyntax/SymbolTest.php b/tests/Version/RubyVM/GenericSyntax/SymbolTest.php
index 6f324264..8f459ef5 100644
--- a/tests/Version/RubyVM/GenericSyntax/SymbolTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/SymbolTest.php
@@ -29,7 +29,7 @@ public function testSymbol(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame(<<<'_'
diff --git a/tests/Version/RubyVM/GenericSyntax/VariadicTest.php b/tests/Version/RubyVM/GenericSyntax/VariadicTest.php
index bac61d05..6c081ffd 100644
--- a/tests/Version/RubyVM/GenericSyntax/VariadicTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/VariadicTest.php
@@ -34,7 +34,7 @@ public function testVariadicArguments(): void
 
         $executor = $rubyVMManager
             ->rubyVM
-            ->disassemble(RubyVersion::VERSION_3_2);
+            ->disassemble();
 
         $this->assertSame(ExecutedStatus::SUCCESS, $executor->execute()->executedStatus);
         $this->assertSame("1\n2\n3\n4\n5\n", $rubyVMManager->stdOut->readAll());

From c335afb8eaf1d10cef847578d91d6bee1d8b2660 Mon Sep 17 00:00:00 2001
From: m3m0r7 <memory.style.serv@gmail.com>
Date: Mon, 25 Dec 2023 19:26:31 +0900
Subject: [PATCH 03/11] Fix problem

---
 src/VM/Core/Runtime/RubyVM.php                  |  8 ++++----
 tests/Helper/TestApplication.php                | 15 +++++++++++++--
 tests/Version/RubyVM/YARB/YARBStructureTest.php |  2 +-
 3 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/src/VM/Core/Runtime/RubyVM.php b/src/VM/Core/Runtime/RubyVM.php
index 0b446624..a93e5485 100644
--- a/src/VM/Core/Runtime/RubyVM.php
+++ b/src/VM/Core/Runtime/RubyVM.php
@@ -27,13 +27,13 @@ public function __construct(public readonly Option $option)
     {
         // Register default kernels
         $this->register(
-            rubyVersion: RubyVersion::VERSION_3_2,
-            kernelClass: \RubyVM\VM\Core\Runtime\Kernel\Ruby3_2\Kernel::class,
+            rubyVersion: RubyVersion::VERSION_3_3,
+            kernelClass: \RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Kernel::class,
         );
 
         $this->register(
-            rubyVersion: RubyVersion::VERSION_3_3,
-            kernelClass: \RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Kernel::class,
+            rubyVersion: RubyVersion::VERSION_3_2,
+            kernelClass: \RubyVM\VM\Core\Runtime\Kernel\Ruby3_2\Kernel::class,
         );
     }
 
diff --git a/tests/Helper/TestApplication.php b/tests/Helper/TestApplication.php
index 08e39a2f..c50a15fa 100644
--- a/tests/Helper/TestApplication.php
+++ b/tests/Helper/TestApplication.php
@@ -15,6 +15,10 @@
  */
 class TestApplication extends TestCase
 {
+    protected int $major = -1;
+    protected int $minor = -1;
+    protected int $patch = -1;
+
     protected function createRubyVMFromCode(string $code, string $extraData = '', string $binaryPath = 'ruby'): RubyVMManager
     {
         $handle = tmpfile();
@@ -22,7 +26,14 @@ protected function createRubyVMFromCode(string $code, string $extraData = '', st
             throw new \RuntimeException('tmpfile did not created');
         }
 
-        [$major, $minor, $patch] = sscanf(exec("{$binaryPath} -v"), 'ruby %d.%d.%d');
+        if ($this->major !== -1) {
+            $version = sscanf(exec("{$binaryPath} -v") ?: 'ruby 3.2.0', 'ruby %d.%d.%d');
+            if (!is_array($version)) {
+                throw new \RuntimeException('The version is incorrect6');
+            }
+
+            [$this->major, $this->minor, $this->patch] = $version;
+        }
 
         fwrite($handle, $code);
         $uri = stream_get_meta_data($handle)['uri'];
@@ -62,7 +73,7 @@ protected function createRubyVMFromCode(string $code, string $extraData = '', st
         );
 
         $rubyVM->setDefaultVersion(
-            RubyVersion::from("{$major}.{$minor}"),
+            RubyVersion::from("{$this->major}.{$this->minor}"),
         );
 
         return new RubyVMManager(
diff --git a/tests/Version/RubyVM/YARB/YARBStructureTest.php b/tests/Version/RubyVM/YARB/YARBStructureTest.php
index f23a00e8..3e93b791 100644
--- a/tests/Version/RubyVM/YARB/YARBStructureTest.php
+++ b/tests/Version/RubyVM/YARB/YARBStructureTest.php
@@ -21,7 +21,7 @@ public function testHeader(): void
             _,
         );
         $rubyVMManager->rubyVM->runtime()->setup();
-        $this->assertSame('3.2', $rubyVMManager->rubyVM->runtime()->rubyVersion());
+        $this->assertSame("{$this->major}.{$this->minor}", $rubyVMManager->rubyVM->runtime()->rubyVersion());
         if ($this->isCI()) {
             $this->assertSame('x86_64-linux', $rubyVMManager->rubyVM->runtime()->rubyPlatform());
         } else {

From 0bdd5b3774579cdef1176cbac843a661c1e07808 Mon Sep 17 00:00:00 2001
From: m3m0r7 <memory.style.serv@gmail.com>
Date: Mon, 25 Dec 2023 19:27:59 +0900
Subject: [PATCH 04/11] Fix incorrect comparison

---
 tests/Helper/TestApplication.php | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/Helper/TestApplication.php b/tests/Helper/TestApplication.php
index c50a15fa..1904455c 100644
--- a/tests/Helper/TestApplication.php
+++ b/tests/Helper/TestApplication.php
@@ -26,7 +26,7 @@ protected function createRubyVMFromCode(string $code, string $extraData = '', st
             throw new \RuntimeException('tmpfile did not created');
         }
 
-        if ($this->major !== -1) {
+        if ($this->major === -1) {
             $version = sscanf(exec("{$binaryPath} -v") ?: 'ruby 3.2.0', 'ruby %d.%d.%d');
             if (!is_array($version)) {
                 throw new \RuntimeException('The version is incorrect6');

From 11a8ef6d7a60e84ef2e4d16198c63fce4c91cd25 Mon Sep 17 00:00:00 2001
From: m3m0r7 <memory.style.serv@gmail.com>
Date: Mon, 25 Dec 2023 19:31:00 +0900
Subject: [PATCH 05/11] Fix looking for a version

---
 src/VM/Core/Runtime/RubyVM.php | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/VM/Core/Runtime/RubyVM.php b/src/VM/Core/Runtime/RubyVM.php
index a93e5485..c646fb11 100644
--- a/src/VM/Core/Runtime/RubyVM.php
+++ b/src/VM/Core/Runtime/RubyVM.php
@@ -101,12 +101,7 @@ public function runtime(RubyVersion $useVersion = null): Runtime
     {
         $selectedVersion = null;
 
-        // @var Runtime|null $kernel
-        if (!$useVersion instanceof \RubyVM\VM\Core\YARV\RubyVersion) {
-            $runtime = $this->registeredRuntimes[$selectedVersion = array_key_first($this->registeredRuntimes)] ?? null;
-        } else {
-            $runtime = $this->registeredRuntimes[$selectedVersion = $useVersion->value] ?? null;
-        }
+        $runtime = $this->registeredRuntimes[$selectedVersion = $useVersion?->value ?? $this->specifiedDefaultVersion->value] ?? null;
 
         if (!$runtime instanceof \RubyVM\VM\Core\Runtime\Runtime) {
             throw new RubyVMException('The RubyVM is not registered a kernel - You should call RubyVM::register method before calling the disassemble method');

From 53b289b4b9469c305ff120a484c8f7ad0bac2066 Mon Sep 17 00:00:00 2001
From: m3m0r7 <memory.style.serv@gmail.com>
Date: Mon, 25 Dec 2023 19:36:09 +0900
Subject: [PATCH 06/11] Fix workflow

---
 .github/workflows/php.yml        |  8 ++++----
 tests/Helper/TestApplication.php | 12 ++++++++----
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/php.yml b/.github/workflows/php.yml
index 427458b5..634985ce 100644
--- a/.github/workflows/php.yml
+++ b/.github/workflows/php.yml
@@ -6,7 +6,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['3.2', '3.3.0-rc1']
+        ruby: ['3.2', '3.3.0-rc1']
     steps:
       - uses: actions/checkout@v3
       - name: Setup PHP
@@ -16,7 +16,7 @@ jobs:
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1.162.0
         with:
-          ruby-version: ${{ matrix.ruby-version }}
+          ruby-version: ${{ matrix.ruby }}
       - name: composer cache
         uses: actions/cache@v3
         with:
@@ -37,7 +37,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['3.2', '3.3.0-rc1']
+        ruby: ['3.2', '3.3.0-rc1']
     steps:
       - uses: actions/checkout@v3
       - name: Setup PHP
@@ -47,7 +47,7 @@ jobs:
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1.162.0
         with:
-          ruby-version: ${{ matrix.ruby-version }}
+          ruby-version: ${{ matrix.ruby }}
       - name: composer cache
         uses: actions/cache@v3
         with:
diff --git a/tests/Helper/TestApplication.php b/tests/Helper/TestApplication.php
index 1904455c..d9749a84 100644
--- a/tests/Helper/TestApplication.php
+++ b/tests/Helper/TestApplication.php
@@ -15,9 +15,9 @@
  */
 class TestApplication extends TestCase
 {
-    protected int $major = -1;
-    protected int $minor = -1;
-    protected int $patch = -1;
+    protected ?int $major = null;
+    protected ?int $minor = null;
+    protected ?int $patch = null;
 
     protected function createRubyVMFromCode(string $code, string $extraData = '', string $binaryPath = 'ruby'): RubyVMManager
     {
@@ -26,13 +26,17 @@ protected function createRubyVMFromCode(string $code, string $extraData = '', st
             throw new \RuntimeException('tmpfile did not created');
         }
 
-        if ($this->major === -1) {
+        if ($this->major === null) {
             $version = sscanf(exec("{$binaryPath} -v") ?: 'ruby 3.2.0', 'ruby %d.%d.%d');
             if (!is_array($version)) {
                 throw new \RuntimeException('The version is incorrect6');
             }
 
             [$this->major, $this->minor, $this->patch] = $version;
+
+            $this->major ??= 3;
+            $this->minor ??= 2;
+            $this->patch ??= 0;
         }
 
         fwrite($handle, $code);

From 0e0a7b780b40e71bdcfd90f9de50435ae22404c8 Mon Sep 17 00:00:00 2001
From: m3m0r7 <memory.style.serv@gmail.com>
Date: Tue, 26 Dec 2023 19:38:26 +0900
Subject: [PATCH 07/11] WIP

---
 .github/workflows/php.yml                     | 8 ++++----
 .ruby-version                                 | 1 +
 src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php | 6 ++++++
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/php.yml b/.github/workflows/php.yml
index 634985ce..be7e1467 100644
--- a/.github/workflows/php.yml
+++ b/.github/workflows/php.yml
@@ -6,7 +6,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['3.2', '3.3.0-rc1']
+        ruby: ['3.2', '3.3.0']
     steps:
       - uses: actions/checkout@v3
       - name: Setup PHP
@@ -14,7 +14,7 @@ jobs:
         with:
           php-version: '8.2'
       - name: Setup Ruby
-        uses: ruby/setup-ruby@v1.162.0
+        uses: ruby/setup-ruby@v1.163.0
         with:
           ruby-version: ${{ matrix.ruby }}
       - name: composer cache
@@ -37,7 +37,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['3.2', '3.3.0-rc1']
+        ruby: ['3.2', '3.3.0']
     steps:
       - uses: actions/checkout@v3
       - name: Setup PHP
@@ -45,7 +45,7 @@ jobs:
         with:
           php-version: '8.2'
       - name: Setup Ruby
-        uses: ruby/setup-ruby@v1.162.0
+        uses: ruby/setup-ruby@v1.163.0
         with:
           ruby-version: ${{ matrix.ruby }}
       - name: composer cache
diff --git a/.ruby-version b/.ruby-version
index e69de29b..15a27998 100644
--- a/.ruby-version
+++ b/.ruby-version
@@ -0,0 +1 @@
+3.3.0
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php
index 36f3b898..87a2bcd7 100644
--- a/src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php
@@ -72,6 +72,10 @@ class Kernel implements KernelInterface
 
     public readonly int $globalObjectListOffset;
 
+    public readonly int $endian;
+
+    public readonly int $short;
+
     public readonly Offsets $instructionSequenceList;
 
     public readonly Offsets $globalObjectList;
@@ -124,6 +128,8 @@ public function setup(): self
         $this->globalObjectListSize = $this->stream()->readAsUnsignedLong();
         $this->instructionSequenceListOffset = $this->stream()->readAsUnsignedLong();
         $this->globalObjectListOffset = $this->stream()->readAsUnsignedLong();
+        $this->endian = $this->stream()->readAsShort();
+        $this->wordSize = $this->stream()->readAsShort();
         $this->rubyPlatform = $this->stream()->readAsString();
 
         $this->vm->option()->logger->info(

From 233a5d7414df6aae157a863665630d8631580ca4 Mon Sep 17 00:00:00 2001
From: m3m0r7 <memory.style.serv@gmail.com>
Date: Wed, 27 Dec 2023 00:53:53 +0900
Subject: [PATCH 08/11] Update dependencies and rewrite architecture

---
 README.md                                     |   4 +-
 .../Runtime/Essential/KernelInterface.php     |   3 +
 .../Executor/Debugger/DebuggerInterface.php   |   6 +-
 .../Debugger/DefaultExecutorDebugger.php      |  37 +-
 .../Debugger/NullExecutorDebugger.php         |   6 +-
 .../Executor/Debugger/StepByStepDebugger.php  |   6 +-
 src/VM/Core/Runtime/Executor/Executor.php     |   4 +-
 .../Runtime/Executor/Insn/InsnInterface.php   |  10 +
 .../Insn/Processor/BuiltinAdjuststack.php     |   6 +-
 .../Insn/Processor/BuiltinAnytostring.php     |   6 +-
 .../Insn/Processor/BuiltinBranchif.php        |   6 +-
 .../Insn/Processor/BuiltinBranchnil.php       |   6 +-
 .../Insn/Processor/BuiltinBranchunless.php    |   6 +-
 .../Insn/Processor/BuiltinCheckkeyword.php    |   6 +-
 .../Insn/Processor/BuiltinCheckmatch.php      |   6 +-
 .../Insn/Processor/BuiltinChecktype.php       |   6 +-
 .../Insn/Processor/BuiltinConcatarray.php     |   6 +-
 .../Insn/Processor/BuiltinConcatstrings.php   |   6 +-
 .../Insn/Processor/BuiltinDefineclass.php     |   6 +-
 .../Insn/Processor/BuiltinDefined.php         |   6 +-
 .../Insn/Processor/BuiltinDefinemethod.php    |   6 +-
 .../Insn/Processor/BuiltinDefinesmethod.php   |   6 +-
 .../Executor/Insn/Processor/BuiltinDup.php    |   6 +-
 .../Insn/Processor/BuiltinDuparray.php        |   6 +-
 .../Insn/Processor/BuiltinDuphash.php         |   6 +-
 .../Executor/Insn/Processor/BuiltinDupn.php   |   6 +-
 .../Insn/Processor/BuiltinExpandarray.php     |   6 +-
 .../Insn/Processor/BuiltinGetblockparam.php   |   6 +-
 .../Processor/BuiltinGetblockparamproxy.php   |   6 +-
 .../Processor/BuiltinGetclassvariable.php     |   6 +-
 .../Insn/Processor/BuiltinGetconstant.php     |   6 +-
 .../Insn/Processor/BuiltinGetglobal.php       |   6 +-
 .../Processor/BuiltinGetinstancevariable.php  |   6 +-
 .../Insn/Processor/BuiltinGetlocal.php        |   6 +-
 .../Insn/Processor/BuiltinGetlocalWC0.php     |   6 +-
 .../Insn/Processor/BuiltinGetlocalWC1.php     |   6 +-
 .../Insn/Processor/BuiltinGetspecial.php      |   6 +-
 .../Executor/Insn/Processor/BuiltinIntern.php |   6 +-
 .../Insn/Processor/BuiltinInvokeblock.php     |   6 +-
 .../Insn/Processor/BuiltinInvokebuiltin.php   |   6 +-
 .../Insn/Processor/BuiltinInvokesuper.php     |   6 +-
 .../Executor/Insn/Processor/BuiltinJump.php   |   6 +-
 .../Executor/Insn/Processor/BuiltinLeave.php  |   6 +-
 .../Insn/Processor/BuiltinNewarray.php        |   6 +-
 .../Insn/Processor/BuiltinNewarraykwsplat.php |   6 +-
 .../Insn/Processor/BuiltinNewhash.php         |   6 +-
 .../Insn/Processor/BuiltinNewrange.php        |   6 +-
 .../Executor/Insn/Processor/BuiltinNop.php    |   6 +-
 .../Insn/Processor/BuiltinObjtostring.php     |   6 +-
 .../Executor/Insn/Processor/BuiltinOnce.php   |   6 +-
 .../Executor/Insn/Processor/BuiltinOptAnd.php |   6 +-
 .../Insn/Processor/BuiltinOptAref.php         |   6 +-
 .../Insn/Processor/BuiltinOptArefWith.php     |   6 +-
 .../Insn/Processor/BuiltinOptAset.php         |   6 +-
 .../Insn/Processor/BuiltinOptAsetWith.php     |   6 +-
 .../Insn/Processor/BuiltinOptCaseDispatch.php |   6 +-
 .../Executor/Insn/Processor/BuiltinOptDiv.php |   6 +-
 .../Insn/Processor/BuiltinOptEmptyP.php       |   6 +-
 .../Executor/Insn/Processor/BuiltinOptEq.php  |   6 +-
 .../Executor/Insn/Processor/BuiltinOptGe.php  |   6 +-
 .../Processor/BuiltinOptGetconstantPath.php   |   6 +-
 .../Executor/Insn/Processor/BuiltinOptGt.php  |   6 +-
 .../BuiltinOptInvokebuiltinDelegate.php       |   6 +-
 .../BuiltinOptInvokebuiltinDelegateLeave.php  |   6 +-
 .../Executor/Insn/Processor/BuiltinOptLe.php  |   6 +-
 .../Insn/Processor/BuiltinOptLength.php       |   6 +-
 .../Executor/Insn/Processor/BuiltinOptLt.php  |   6 +-
 .../Insn/Processor/BuiltinOptLtlt.php         |   6 +-
 .../Insn/Processor/BuiltinOptMinus.php        |   6 +-
 .../Executor/Insn/Processor/BuiltinOptMod.php |   6 +-
 .../Insn/Processor/BuiltinOptMult.php         |   6 +-
 .../Executor/Insn/Processor/BuiltinOptNeq.php |   6 +-
 .../Insn/Processor/BuiltinOptNewarrayMax.php  |   6 +-
 .../Insn/Processor/BuiltinOptNewarrayMin.php  |   6 +-
 .../Insn/Processor/BuiltinOptNilP.php         |   6 +-
 .../Executor/Insn/Processor/BuiltinOptNot.php |   6 +-
 .../Executor/Insn/Processor/BuiltinOptOr.php  |   6 +-
 .../Insn/Processor/BuiltinOptPlus.php         |   6 +-
 .../Insn/Processor/BuiltinOptRegexpmatch2.php |   6 +-
 .../Insn/Processor/BuiltinOptReverse.php      |   6 +-
 .../Processor/BuiltinOptSendWithoutBlock.php  |   6 +-
 .../Insn/Processor/BuiltinOptSize.php         |   6 +-
 .../Insn/Processor/BuiltinOptStrFreeze.php    |   6 +-
 .../Insn/Processor/BuiltinOptStrUminus.php    |   6 +-
 .../Insn/Processor/BuiltinOptSucc.php         |   6 +-
 .../Executor/Insn/Processor/BuiltinPop.php    |   6 +-
 .../Executor/Insn/Processor/BuiltinPutnil.php |   6 +-
 .../Insn/Processor/BuiltinPutobject.php       |   6 +-
 .../Processor/BuiltinPutobjectINT2FIX0.php    |   6 +-
 .../Processor/BuiltinPutobjectINT2FIX1.php    |   6 +-
 .../Insn/Processor/BuiltinPutself.php         |   6 +-
 .../Processor/BuiltinPutspecialobject.php     |   6 +-
 .../Insn/Processor/BuiltinPutstring.php       |   6 +-
 .../Executor/Insn/Processor/BuiltinSend.php   |   6 +-
 .../Insn/Processor/BuiltinSetblockparam.php   |   6 +-
 .../Processor/BuiltinSetclassvariable.php     |   6 +-
 .../Insn/Processor/BuiltinSetconstant.php     |   6 +-
 .../Insn/Processor/BuiltinSetglobal.php       |   6 +-
 .../Processor/BuiltinSetinstancevariable.php  |   6 +-
 .../Insn/Processor/BuiltinSetlocal.php        |   6 +-
 .../Insn/Processor/BuiltinSetlocalWC0.php     |   6 +-
 .../Insn/Processor/BuiltinSetlocalWC1.php     |   6 +-
 .../Executor/Insn/Processor/BuiltinSetn.php   |   6 +-
 .../Insn/Processor/BuiltinSetspecial.php      |   6 +-
 .../Insn/Processor/BuiltinSplatarray.php      |   6 +-
 .../Executor/Insn/Processor/BuiltinSwap.php   |   6 +-
 .../Executor/Insn/Processor/BuiltinThrow.php  |   6 +-
 .../Executor/Insn/Processor/BuiltinTopn.php   |   6 +-
 .../Insn/Processor/BuiltinToregexp.php        |   6 +-
 .../Processor/BuiltinTraceAdjuststack.php     |   6 +-
 .../Processor/BuiltinTraceAnytostring.php     |   6 +-
 .../Insn/Processor/BuiltinTraceBranchif.php   |   6 +-
 .../Insn/Processor/BuiltinTraceBranchnil.php  |   6 +-
 .../Processor/BuiltinTraceBranchunless.php    |   6 +-
 .../Processor/BuiltinTraceCheckkeyword.php    |   6 +-
 .../Insn/Processor/BuiltinTraceCheckmatch.php |   6 +-
 .../Insn/Processor/BuiltinTraceChecktype.php  |   6 +-
 .../Processor/BuiltinTraceConcatarray.php     |   6 +-
 .../Processor/BuiltinTraceConcatstrings.php   |   6 +-
 .../Processor/BuiltinTraceDefineclass.php     |   6 +-
 .../Insn/Processor/BuiltinTraceDefined.php    |   6 +-
 .../Processor/BuiltinTraceDefinemethod.php    |   6 +-
 .../Processor/BuiltinTraceDefinesmethod.php   |   6 +-
 .../Insn/Processor/BuiltinTraceDup.php        |   6 +-
 .../Insn/Processor/BuiltinTraceDuparray.php   |   6 +-
 .../Insn/Processor/BuiltinTraceDuphash.php    |   6 +-
 .../Insn/Processor/BuiltinTraceDupn.php       |   6 +-
 .../Processor/BuiltinTraceExpandarray.php     |   6 +-
 .../Processor/BuiltinTraceGetblockparam.php   |   6 +-
 .../BuiltinTraceGetblockparamproxy.php        |   6 +-
 .../BuiltinTraceGetclassvariable.php          |   6 +-
 .../Processor/BuiltinTraceGetconstant.php     |   6 +-
 .../Insn/Processor/BuiltinTraceGetglobal.php  |   6 +-
 .../BuiltinTraceGetinstancevariable.php       |   6 +-
 .../Insn/Processor/BuiltinTraceGetlocal.php   |   6 +-
 .../Processor/BuiltinTraceGetlocalWC0.php     |   6 +-
 .../Processor/BuiltinTraceGetlocalWC1.php     |   6 +-
 .../Insn/Processor/BuiltinTraceGetspecial.php |   6 +-
 .../Insn/Processor/BuiltinTraceIntern.php     |   6 +-
 .../Processor/BuiltinTraceInvokeblock.php     |   6 +-
 .../Processor/BuiltinTraceInvokebuiltin.php   |   6 +-
 .../Processor/BuiltinTraceInvokesuper.php     |   6 +-
 .../Insn/Processor/BuiltinTraceJump.php       |   6 +-
 .../Insn/Processor/BuiltinTraceLeave.php      |   6 +-
 .../Insn/Processor/BuiltinTraceNewarray.php   |   6 +-
 .../Processor/BuiltinTraceNewarraykwsplat.php |   6 +-
 .../Insn/Processor/BuiltinTraceNewhash.php    |   6 +-
 .../Insn/Processor/BuiltinTraceNewrange.php   |   6 +-
 .../Insn/Processor/BuiltinTraceNop.php        |   6 +-
 .../Processor/BuiltinTraceObjtostring.php     |   6 +-
 .../Insn/Processor/BuiltinTraceOnce.php       |   6 +-
 .../Insn/Processor/BuiltinTraceOptAnd.php     |   6 +-
 .../Insn/Processor/BuiltinTraceOptAref.php    |   6 +-
 .../Processor/BuiltinTraceOptArefWith.php     |   6 +-
 .../Insn/Processor/BuiltinTraceOptAset.php    |   6 +-
 .../Processor/BuiltinTraceOptAsetWith.php     |   6 +-
 .../Processor/BuiltinTraceOptCaseDispatch.php |   6 +-
 .../Insn/Processor/BuiltinTraceOptDiv.php     |   6 +-
 .../Insn/Processor/BuiltinTraceOptEmptyP.php  |   6 +-
 .../Insn/Processor/BuiltinTraceOptEq.php      |   6 +-
 .../Insn/Processor/BuiltinTraceOptGe.php      |   6 +-
 .../BuiltinTraceOptGetconstantPath.php        |   6 +-
 .../Insn/Processor/BuiltinTraceOptGt.php      |   6 +-
 .../BuiltinTraceOptInvokebuiltinDelegate.php  |   6 +-
 ...ltinTraceOptInvokebuiltinDelegateLeave.php |   6 +-
 .../Insn/Processor/BuiltinTraceOptLe.php      |   6 +-
 .../Insn/Processor/BuiltinTraceOptLength.php  |   6 +-
 .../Insn/Processor/BuiltinTraceOptLt.php      |   6 +-
 .../Insn/Processor/BuiltinTraceOptLtlt.php    |   6 +-
 .../Insn/Processor/BuiltinTraceOptMinus.php   |   6 +-
 .../Insn/Processor/BuiltinTraceOptMod.php     |   6 +-
 .../Insn/Processor/BuiltinTraceOptMult.php    |   6 +-
 .../Insn/Processor/BuiltinTraceOptNeq.php     |   6 +-
 .../Processor/BuiltinTraceOptNewarrayMax.php  |   6 +-
 .../Processor/BuiltinTraceOptNewarrayMin.php  |   6 +-
 .../Insn/Processor/BuiltinTraceOptNilP.php    |   6 +-
 .../Insn/Processor/BuiltinTraceOptNot.php     |   6 +-
 .../Insn/Processor/BuiltinTraceOptOr.php      |   6 +-
 .../Insn/Processor/BuiltinTraceOptPlus.php    |   6 +-
 .../Processor/BuiltinTraceOptRegexpmatch2.php |   6 +-
 .../Insn/Processor/BuiltinTraceOptReverse.php |   6 +-
 .../BuiltinTraceOptSendWithoutBlock.php       |   6 +-
 .../Insn/Processor/BuiltinTraceOptSize.php    |   6 +-
 .../Processor/BuiltinTraceOptStrFreeze.php    |   6 +-
 .../Processor/BuiltinTraceOptStrUminus.php    |   6 +-
 .../Insn/Processor/BuiltinTraceOptSucc.php    |   6 +-
 .../Insn/Processor/BuiltinTracePop.php        |   6 +-
 .../Insn/Processor/BuiltinTracePutnil.php     |   6 +-
 .../Insn/Processor/BuiltinTracePutobject.php  |   6 +-
 .../BuiltinTracePutobjectINT2FIX0.php         |   6 +-
 .../BuiltinTracePutobjectINT2FIX1.php         |   6 +-
 .../Insn/Processor/BuiltinTracePutself.php    |   6 +-
 .../BuiltinTracePutspecialobject.php          |   6 +-
 .../Insn/Processor/BuiltinTracePutstring.php  |   6 +-
 .../Insn/Processor/BuiltinTraceSend.php       |   6 +-
 .../Processor/BuiltinTraceSetblockparam.php   |   6 +-
 .../BuiltinTraceSetclassvariable.php          |   6 +-
 .../Processor/BuiltinTraceSetconstant.php     |   6 +-
 .../Insn/Processor/BuiltinTraceSetglobal.php  |   6 +-
 .../BuiltinTraceSetinstancevariable.php       |   6 +-
 .../Insn/Processor/BuiltinTraceSetlocal.php   |   6 +-
 .../Processor/BuiltinTraceSetlocalWC0.php     |   6 +-
 .../Processor/BuiltinTraceSetlocalWC1.php     |   6 +-
 .../Insn/Processor/BuiltinTraceSetn.php       |   6 +-
 .../Insn/Processor/BuiltinTraceSetspecial.php |   6 +-
 .../Insn/Processor/BuiltinTraceSplatarray.php |   6 +-
 .../Insn/Processor/BuiltinTraceSwap.php       |   6 +-
 .../Insn/Processor/BuiltinTraceThrow.php      |   6 +-
 .../Insn/Processor/BuiltinTraceTopn.php       |   6 +-
 .../Insn/Processor/BuiltinTraceToregexp.php   |   6 +-
 .../Runtime/Executor/Operation/Operation.php  |   4 +-
 .../Processor/OperationProcessorEntries.php   |   6 +-
 .../Processor/OperationProcessorInterface.php |   4 +-
 .../Ruby3_2/InstructionSequence}/Insn.php     |   5 +-
 .../InstructionSequenceProcessor.php          |   1 -
 .../OperationProcessorEntries.php}            |   7 +-
 src/VM/Core/Runtime/Kernel/Ruby3_2/Kernel.php |   9 +-
 .../Ruby3_3/InstructionSequence/Insn.php      | 218 +++++++++
 .../InstructionSequenceProcessor.php          | 113 +++--
 .../OperationProcessorEntries.php             | 415 ++++++++++++++++++
 src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php |  11 +-
 src/VM/Core/Runtime/Option.php                |   7 -
 src/VM/Core/Runtime/OptionInterface.php       |   2 -
 tests/Internal/DebugFormatTest.php            |  10 +-
 .../Version/RubyVM/YARB/YARBStructureTest.php |   6 +-
 225 files changed, 1388 insertions(+), 718 deletions(-)
 create mode 100644 src/VM/Core/Runtime/Executor/Insn/InsnInterface.php
 rename src/VM/Core/Runtime/{Executor/Insn => Kernel/Ruby3_2/InstructionSequence}/Insn.php (97%)
 rename src/VM/Core/Runtime/{Executor/Operation/DefaultOperationProcessorEntries.php => Kernel/Ruby3_2/InstructionSequence/OperationProcessorEntries.php} (99%)
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Insn.php
 create mode 100644 src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/OperationProcessorEntries.php

diff --git a/README.md b/README.md
index 69c5d151..796c6929 100644
--- a/README.md
+++ b/README.md
@@ -252,11 +252,13 @@ $ ./vendor/bin/phpunit tests/
 
 1) Build your ruby environment from source code with `-DIBF_ISEQ_DEBUG` flag
 
+See: https://docs.ruby-lang.org/en/master/contributing/building_ruby_md.html
+
 ```
 $ git clone git@github.com:ruby/ruby.git
 $ mkdir build && cd build
 $ ../configure cppflags="-DIBF_ISEQ_DEBUG=1"
-$ make -j16
+$ make -j$(nproc)
 ```
 
 2) When you built ruby environment, you will got `vm.inc` file which is wrote how to execute each INSN commands
diff --git a/src/VM/Core/Runtime/Essential/KernelInterface.php b/src/VM/Core/Runtime/Essential/KernelInterface.php
index 02c30fa0..d7b701f2 100644
--- a/src/VM/Core/Runtime/Essential/KernelInterface.php
+++ b/src/VM/Core/Runtime/Essential/KernelInterface.php
@@ -4,6 +4,7 @@
 
 namespace RubyVM\VM\Core\Runtime\Essential;
 
+use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorEntries;
 use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\Aux\Aux;
 use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\InstructionSequence;
 use RubyVM\VM\Core\YARV\Criterion\Offset\Offsets;
@@ -45,4 +46,6 @@ public function instructionSequenceListSize(): int;
     public function instructionSequenceListOffset(): int;
 
     public function instructionSequenceList(): Offsets;
+
+    public function operationProcessorEntries(): OperationProcessorEntries;
 }
diff --git a/src/VM/Core/Runtime/Executor/Debugger/DebuggerInterface.php b/src/VM/Core/Runtime/Executor/Debugger/DebuggerInterface.php
index 6af53c53..f589bc76 100644
--- a/src/VM/Core/Runtime/Executor/Debugger/DebuggerInterface.php
+++ b/src/VM/Core/Runtime/Executor/Debugger/DebuggerInterface.php
@@ -6,7 +6,7 @@
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
 use RubyVM\VM\Core\Runtime\Executor\ExecutedResult;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 
 interface DebuggerInterface
 {
@@ -14,9 +14,9 @@ public function enter(ContextInterface $context): void;
 
     public function leave(ExecutedResult $result): void;
 
-    public function append(Insn $insn, ContextInterface $context): void;
+    public function append(InsnInterface $insn, ContextInterface $context): void;
 
-    public function process(Insn $insn, ContextInterface $context): void;
+    public function process(InsnInterface $insn, ContextInterface $context): void;
 
     public function showExecutedOperations(): void;
 }
diff --git a/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php b/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php
index 30a2e8f8..1556d1c3 100644
--- a/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php
+++ b/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php
@@ -7,8 +7,10 @@
 use RubyVM\VM\Core\Helper\ClassHelper;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
 use RubyVM\VM\Core\Runtime\Executor\ExecutedResult;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_2\InstructionSequence\Insn as Ruby3_2_Insn;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence\Insn as Ruby3_3_Insn;
 use RubyVM\VM\Core\YARV\Criterion\InstructionSequence\CallInfoInterface;
 use RubyVM\VM\Exception\RubyVMException;
 use Symfony\Component\Console\Helper\Table;
@@ -20,7 +22,7 @@ class DefaultExecutorDebugger implements DebuggerInterface
     use DebugFormat;
 
     /**
-     * @var array<array{Insn, ContextInterface, int, null|string}>
+     * @var array<array{InsnInterface, ContextInterface, int, null|string}>
      */
     protected array $snapshots = [];
 
@@ -38,7 +40,7 @@ public function __debugInfo(): array
         return [];
     }
 
-    public function append(Insn $insn, ContextInterface $context): void
+    public function append(InsnInterface $insn, ContextInterface $context): void
     {
         $this->snapshots[] = [
             $insn,
@@ -106,19 +108,28 @@ public function showExecutedOperations(): void
         $table->render();
     }
 
-    private function makeDetails(Insn $insn, ContextInterface $context): ?string
+    private function makeDetails(InsnInterface $insn, ContextInterface $context): ?string
     {
         $context = $context->createSnapshot();
 
+        // TODO: Rewrite here to depending on running kernel, but here is hard coded.
         return match ($insn) {
-            Insn::SEND,
-            Insn::OPT_SEND_WITHOUT_BLOCK => $this->debugCallMethod($context),
-            Insn::GETLOCAL,
-            Insn::GETLOCAL_WC_0,
-            Insn::GETLOCAL_WC_1,
-            Insn::SETLOCAL,
-            Insn::SETLOCAL_WC_0,
-            Insn::SETLOCAL_WC_1 => $this->debugLocalVariable($context),
+            Ruby3_2_Insn::SEND,
+            Ruby3_2_Insn::OPT_SEND_WITHOUT_BLOCK,
+            Ruby3_3_Insn::SEND,
+            Ruby3_3_Insn::OPT_SEND_WITHOUT_BLOCK => $this->debugCallMethod($context),
+            Ruby3_2_Insn::GETLOCAL,
+            Ruby3_2_Insn::GETLOCAL_WC_0,
+            Ruby3_2_Insn::GETLOCAL_WC_1,
+            Ruby3_2_Insn::SETLOCAL,
+            Ruby3_2_Insn::SETLOCAL_WC_0,
+            Ruby3_2_Insn::SETLOCAL_WC_1,
+            Ruby3_3_Insn::GETLOCAL,
+            Ruby3_3_Insn::GETLOCAL_WC_0,
+            Ruby3_3_Insn::GETLOCAL_WC_1,
+            Ruby3_3_Insn::SETLOCAL,
+            Ruby3_3_Insn::SETLOCAL_WC_0,
+            Ruby3_3_Insn::SETLOCAL_WC_1 => $this->debugLocalVariable($context),
             default => null,
         };
     }
@@ -190,5 +201,5 @@ public function enter(ContextInterface $context): void
 
     public function leave(ExecutedResult $result): void {}
 
-    public function process(Insn $insn, ContextInterface $context): void {}
+    public function process(InsnInterface $insn, ContextInterface $context): void {}
 }
diff --git a/src/VM/Core/Runtime/Executor/Debugger/NullExecutorDebugger.php b/src/VM/Core/Runtime/Executor/Debugger/NullExecutorDebugger.php
index 116c1ba3..71257f1f 100644
--- a/src/VM/Core/Runtime/Executor/Debugger/NullExecutorDebugger.php
+++ b/src/VM/Core/Runtime/Executor/Debugger/NullExecutorDebugger.php
@@ -6,7 +6,7 @@
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
 use RubyVM\VM\Core\Runtime\Executor\ExecutedResult;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 
 class NullExecutorDebugger implements DebuggerInterface
 {
@@ -14,9 +14,9 @@ public function enter(ContextInterface $context): void {}
 
     public function leave(ExecutedResult $result): void {}
 
-    public function append(Insn $insn, ContextInterface $context): void {}
+    public function append(InsnInterface $insn, ContextInterface $context): void {}
 
     public function showExecutedOperations(): void {}
 
-    public function process(Insn $insn, ContextInterface $context): void {}
+    public function process(InsnInterface $insn, ContextInterface $context): void {}
 }
diff --git a/src/VM/Core/Runtime/Executor/Debugger/StepByStepDebugger.php b/src/VM/Core/Runtime/Executor/Debugger/StepByStepDebugger.php
index 1091002e..bbd4f061 100644
--- a/src/VM/Core/Runtime/Executor/Debugger/StepByStepDebugger.php
+++ b/src/VM/Core/Runtime/Executor/Debugger/StepByStepDebugger.php
@@ -5,11 +5,11 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Debugger;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 
 class StepByStepDebugger extends DefaultExecutorDebugger implements DebuggerInterface
 {
-    private function processBreakPoint(Insn $insn, ContextInterface $prevContext, ContextInterface $nextContext): void
+    private function processBreakPoint(InsnInterface $insn, ContextInterface $prevContext, ContextInterface $nextContext): void
     {
         $this->showExecutedOperations();
 
@@ -61,7 +61,7 @@ public function enter(ContextInterface $context): void
         $this->context = $context->createSnapshot();
     }
 
-    public function process(Insn $insn, ContextInterface $context): void
+    public function process(InsnInterface $insn, ContextInterface $context): void
     {
         $this->processBreakPoint(
             $insn,
diff --git a/src/VM/Core/Runtime/Executor/Executor.php b/src/VM/Core/Runtime/Executor/Executor.php
index 7e1915e1..f4f6b14c 100644
--- a/src/VM/Core/Runtime/Executor/Executor.php
+++ b/src/VM/Core/Runtime/Executor/Executor.php
@@ -14,7 +14,7 @@
 use RubyVM\VM\Core\Runtime\Executor\Context\OperationProcessorContext;
 use RubyVM\VM\Core\Runtime\Executor\Context\ProgramCounter;
 use RubyVM\VM\Core\Runtime\Executor\Context\VMStack;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operation;
 use RubyVM\VM\Core\Runtime\Main;
 use RubyVM\VM\Core\Runtime\Option;
@@ -199,7 +199,7 @@ private function _execute(ContextInterface|RubyClassInterface ...$arguments): Ex
             );
 
             $processor = $this
-                ->option
+                ->kernel
                 ->operationProcessorEntries()
                 ->get($operator->insn);
 
diff --git a/src/VM/Core/Runtime/Executor/Insn/InsnInterface.php b/src/VM/Core/Runtime/Executor/Insn/InsnInterface.php
new file mode 100644
index 00000000..4253f0b9
--- /dev/null
+++ b/src/VM/Core/Runtime/Executor/Insn/InsnInterface.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Executor\Insn;
+
+interface InsnInterface
+{
+    public static function of(int $value): self;
+}
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAdjuststack.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAdjuststack.php
index 1410f62b..3f92afc3 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAdjuststack.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAdjuststack.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinAdjuststack implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAnytostring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAnytostring.php
index 62925b91..542b8b88 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAnytostring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAnytostring.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinAnytostring implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchif.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchif.php
index 4cfec352..6b96892f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchif.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchif.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -16,11 +16,11 @@ class BuiltinBranchif implements OperationProcessorInterface
     use OperandHelper;
     use Validatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchnil.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchnil.php
index b4cb10c8..91a4a565 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchnil.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchnil.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinBranchnil implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchunless.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchunless.php
index 5631d6eb..3a87342d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchunless.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchunless.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -16,11 +16,11 @@ class BuiltinBranchunless implements OperationProcessorInterface
     use OperandHelper;
     use Validatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckkeyword.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckkeyword.php
index 4d5252f0..0a665f59 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckkeyword.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckkeyword.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinCheckkeyword implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckmatch.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckmatch.php
index c9b62f84..1765a5a9 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckmatch.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckmatch.php
@@ -8,7 +8,7 @@
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\TrueClass;
 use RubyVM\VM\Core\Runtime\CheckMatchType;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -18,11 +18,11 @@
 class BuiltinCheckmatch implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinChecktype.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinChecktype.php
index 4f921678..e6b498d1 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinChecktype.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinChecktype.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinChecktype implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatarray.php
index 56f5bcad..0fc39bcf 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatarray.php
@@ -6,7 +6,7 @@
 
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Enumerable\Array_;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -15,11 +15,11 @@
 class BuiltinConcatarray implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatstrings.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatstrings.php
index 7aacab25..b13f96f3 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatstrings.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatstrings.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinConcatstrings implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefineclass.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefineclass.php
index c5f80ab4..b16d6120 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefineclass.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefineclass.php
@@ -9,7 +9,7 @@
 use RubyVM\VM\Core\Runtime\ClassCreator;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
 use RubyVM\VM\Core\Runtime\Executor\Executor;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -22,11 +22,11 @@ class BuiltinDefineclass implements OperationProcessorInterface
     use OperandHelper;
     use Validatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefined.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefined.php
index 9a1eff1f..1ffb45f0 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefined.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefined.php
@@ -7,7 +7,7 @@
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Comparable\String_;
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\NilClass;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -16,11 +16,11 @@
 class BuiltinDefined implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinemethod.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinemethod.php
index 5d5f3387..5947fea3 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinemethod.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinemethod.php
@@ -8,7 +8,7 @@
 use RubyVM\VM\Core\Runtime\ClassCreator;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
 use RubyVM\VM\Core\Runtime\Executor\Executor;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -21,11 +21,11 @@ class BuiltinDefinemethod implements OperationProcessorInterface
     use OperandHelper;
     use Validatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinesmethod.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinesmethod.php
index 0cffb0ef..01859dc5 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinesmethod.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinesmethod.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinDefinesmethod implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDup.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDup.php
index 404eb362..97071703 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDup.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDup.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -13,11 +13,11 @@
 class BuiltinDup implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuparray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuparray.php
index a05eabac..347a952d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuparray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuparray.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -17,11 +17,11 @@ class BuiltinDuparray implements OperationProcessorInterface
     use OperandHelper;
     use Validatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuphash.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuphash.php
index b0a30af5..471954eb 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuphash.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuphash.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinDuphash implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDupn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDupn.php
index abc1b340..bd4be721 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDupn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDupn.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinDupn implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinExpandarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinExpandarray.php
index aeb0f08f..16108d66 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinExpandarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinExpandarray.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinExpandarray implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetblockparam.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetblockparam.php
index adbb6c67..8fc60f1c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetblockparam.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetblockparam.php
@@ -6,7 +6,7 @@
 
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Proc;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\LocalTable;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
@@ -19,11 +19,11 @@ class BuiltinGetblockparam implements OperationProcessorInterface
     use LocalTable;
     use OperandHelper;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetblockparamproxy.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetblockparamproxy.php
index c34308c9..3bd56afa 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetblockparamproxy.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetblockparamproxy.php
@@ -6,7 +6,7 @@
 
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Proc;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\LocalTable;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
@@ -19,11 +19,11 @@ class BuiltinGetblockparamproxy implements OperationProcessorInterface
     use LocalTable;
     use OperandHelper;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetclassvariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetclassvariable.php
index 608b79c1..bc2c5ae4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetclassvariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetclassvariable.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinGetclassvariable implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetconstant.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetconstant.php
index 58cc6572..73029dec 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetconstant.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetconstant.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinGetconstant implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetglobal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetglobal.php
index 8625ed02..338a3c96 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetglobal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetglobal.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -14,11 +14,11 @@
 class BuiltinGetglobal implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetinstancevariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetinstancevariable.php
index 06a38962..f9a41977 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetinstancevariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetinstancevariable.php
@@ -6,7 +6,7 @@
 
 use RubyVM\VM\Core\Runtime\Essential\RubyClassImplementationInterface;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -15,11 +15,11 @@
 class BuiltinGetinstancevariable implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetlocal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetlocal.php
index 9a332d34..e4543a8b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetlocal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetlocal.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\LocalTable;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
@@ -17,11 +17,11 @@ class BuiltinGetlocal implements OperationProcessorInterface
     use LocalTable;
     use OperandHelper;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetlocalWC0.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetlocalWC0.php
index 0ac9ee51..97152196 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetlocalWC0.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetlocalWC0.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\LocalTable;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
@@ -17,11 +17,11 @@ class BuiltinGetlocalWC0 implements OperationProcessorInterface
     use OperandHelper;
     use LocalTable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetlocalWC1.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetlocalWC1.php
index 45a88212..9812b11e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetlocalWC1.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetlocalWC1.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\LocalTable;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
@@ -17,11 +17,11 @@ class BuiltinGetlocalWC1 implements OperationProcessorInterface
     use OperandHelper;
     use LocalTable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetspecial.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetspecial.php
index 8d563cac..f13c3db1 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetspecial.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetspecial.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinGetspecial implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinIntern.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinIntern.php
index 581992a4..f1617e0e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinIntern.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinIntern.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinIntern implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokeblock.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokeblock.php
index 69d1d8d4..cec34fb8 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokeblock.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokeblock.php
@@ -7,7 +7,7 @@
 use RubyVM\VM\Core\Runtime\Executor\ArgumentTransformable;
 use RubyVM\VM\Core\Runtime\Executor\CallBlockHelper;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\LocalTable;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
@@ -22,11 +22,11 @@ class BuiltinInvokeblock implements OperationProcessorInterface
     use OperandHelper;
     use CallBlockHelper;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokebuiltin.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokebuiltin.php
index f03e98db..c091214c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokebuiltin.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokebuiltin.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinInvokebuiltin implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokesuper.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokesuper.php
index e6f0913e..0de4d5eb 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokesuper.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokesuper.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinInvokesuper implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinJump.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinJump.php
index 9a2082e0..66265b27 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinJump.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinJump.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -13,11 +13,11 @@
 class BuiltinJump implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinLeave.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinLeave.php
index 87765184..d80d8d2a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinLeave.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinLeave.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -13,11 +13,11 @@
 class BuiltinLeave implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarray.php
index f7f5e145..76cdcf8a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarray.php
@@ -6,7 +6,7 @@
 
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Enumerable\Array_;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -15,11 +15,11 @@
 class BuiltinNewarray implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarraykwsplat.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarraykwsplat.php
index f2cf472d..8100068f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarraykwsplat.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarraykwsplat.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinNewarraykwsplat implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewhash.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewhash.php
index 93033d94..4fc6a3ce 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewhash.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewhash.php
@@ -6,7 +6,7 @@
 
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Enumerable\Hash;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -15,11 +15,11 @@
 class BuiltinNewhash implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewrange.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewrange.php
index b38f249f..87c5ce9a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewrange.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewrange.php
@@ -7,7 +7,7 @@
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Enumerable\Range;
 use RubyVM\VM\Core\Runtime\BasicObject\SymbolizeInterface;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -19,11 +19,11 @@
 class BuiltinNewrange implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNop.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNop.php
index f75b7ab4..ebd88c7a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNop.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNop.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -13,11 +13,11 @@
 class BuiltinNop implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinObjtostring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinObjtostring.php
index 6d129043..efa161e8 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinObjtostring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinObjtostring.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinObjtostring implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOnce.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOnce.php
index e131857a..3a7a7218 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOnce.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOnce.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinOnce implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAnd.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAnd.php
index 784d628d..43fc006d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAnd.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAnd.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\OperatorCalculatable;
@@ -16,11 +16,11 @@ class BuiltinOptAnd implements OperationProcessorInterface
     use OperandHelper;
     use OperatorCalculatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAref.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAref.php
index 86bd8a03..67330e57 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAref.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAref.php
@@ -7,7 +7,7 @@
 use RubyVM\VM\Core\Helper\ClassHelper;
 use RubyVM\VM\Core\Runtime\Essential\RubyClassInterface;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -17,11 +17,11 @@
 class BuiltinOptAref implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptArefWith.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptArefWith.php
index cb4373fb..2c3f5465 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptArefWith.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptArefWith.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinOptArefWith implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAset.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAset.php
index 36ec0f6d..8a2123d9 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAset.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAset.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinOptAset implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAsetWith.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAsetWith.php
index 34986b51..c913dd31 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAsetWith.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAsetWith.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinOptAsetWith implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptCaseDispatch.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptCaseDispatch.php
index 17491ae6..870baaf5 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptCaseDispatch.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptCaseDispatch.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -13,11 +13,11 @@
 class BuiltinOptCaseDispatch implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptDiv.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptDiv.php
index 70c563d8..99f87bb4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptDiv.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptDiv.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\OperatorCalculatable;
@@ -16,11 +16,11 @@ class BuiltinOptDiv implements OperationProcessorInterface
     use OperandHelper;
     use OperatorCalculatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptEmptyP.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptEmptyP.php
index ece059dd..57ddd286 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptEmptyP.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptEmptyP.php
@@ -7,7 +7,7 @@
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\NilClass;
 use RubyVM\VM\Core\Runtime\Essential\RubyClassInterface;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -16,11 +16,11 @@
 class BuiltinOptEmptyP implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptEq.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptEq.php
index 1101d4ad..432d644a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptEq.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptEq.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\OperatorCalculatable;
@@ -16,11 +16,11 @@ class BuiltinOptEq implements OperationProcessorInterface
     use OperandHelper;
     use OperatorCalculatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptGe.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptGe.php
index b6d1e597..4ca74eb3 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptGe.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptGe.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\OperatorCalculatable;
@@ -16,11 +16,11 @@ class BuiltinOptGe implements OperationProcessorInterface
     use OperandHelper;
     use OperatorCalculatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptGetconstantPath.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptGetconstantPath.php
index 776c43b7..712c778f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptGetconstantPath.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptGetconstantPath.php
@@ -6,7 +6,7 @@
 
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Class_;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -17,11 +17,11 @@
 class BuiltinOptGetconstantPath implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptGt.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptGt.php
index c4ff59d8..1cbe8b28 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptGt.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptGt.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\OperatorCalculatable;
@@ -16,11 +16,11 @@ class BuiltinOptGt implements OperationProcessorInterface
     use OperandHelper;
     use OperatorCalculatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegate.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegate.php
index 09c65af6..08efa858 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegate.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegate.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinOptInvokebuiltinDelegate implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegateLeave.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegateLeave.php
index cb91114e..4488584e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegateLeave.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegateLeave.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinOptInvokebuiltinDelegateLeave implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLe.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLe.php
index e35d3522..c63faabc 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLe.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLe.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\OperatorCalculatable;
@@ -16,11 +16,11 @@ class BuiltinOptLe implements OperationProcessorInterface
     use OperandHelper;
     use OperatorCalculatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLength.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLength.php
index 02ed587a..261d7b3d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLength.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLength.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinOptLength implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLt.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLt.php
index f627ed63..755b3008 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLt.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLt.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\OperatorCalculatable;
@@ -16,11 +16,11 @@ class BuiltinOptLt implements OperationProcessorInterface
     use OperandHelper;
     use OperatorCalculatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLtlt.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLtlt.php
index 7ee64788..5da72e24 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLtlt.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLtlt.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\OperatorCalculatable;
@@ -16,11 +16,11 @@ class BuiltinOptLtlt implements OperationProcessorInterface
     use OperandHelper;
     use OperatorCalculatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptMinus.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptMinus.php
index d0ca6982..14d647ef 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptMinus.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptMinus.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\OperatorCalculatable;
@@ -16,11 +16,11 @@ class BuiltinOptMinus implements OperationProcessorInterface
     use OperandHelper;
     use OperatorCalculatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptMod.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptMod.php
index d0a3077d..718d0c6d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptMod.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptMod.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\OperatorCalculatable;
@@ -16,11 +16,11 @@ class BuiltinOptMod implements OperationProcessorInterface
     use OperandHelper;
     use OperatorCalculatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptMult.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptMult.php
index 38f03c96..ecec8021 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptMult.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptMult.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\OperatorCalculatable;
@@ -16,11 +16,11 @@ class BuiltinOptMult implements OperationProcessorInterface
     use OperandHelper;
     use OperatorCalculatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNeq.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNeq.php
index 7a393159..a7b75e7a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNeq.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNeq.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinOptNeq implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMax.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMax.php
index 0a416c91..4fc1a17c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMax.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMax.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinOptNewarrayMax implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMin.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMin.php
index fddbe0f4..4cae6468 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMin.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMin.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinOptNewarrayMin implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNilP.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNilP.php
index 8c2024a2..68c82b81 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNilP.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNilP.php
@@ -7,7 +7,7 @@
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\NilClass;
 use RubyVM\VM\Core\Runtime\Essential\RubyClassInterface;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -16,11 +16,11 @@
 class BuiltinOptNilP implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNot.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNot.php
index f51edae9..fd5be3b1 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNot.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNot.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinOptNot implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptOr.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptOr.php
index ddd3c763..9af0b001 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptOr.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptOr.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\OperatorCalculatable;
@@ -16,11 +16,11 @@ class BuiltinOptOr implements OperationProcessorInterface
     use OperandHelper;
     use OperatorCalculatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptPlus.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptPlus.php
index 19cbc64b..33b3ebe8 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptPlus.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptPlus.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\OperatorCalculatable;
@@ -16,11 +16,11 @@ class BuiltinOptPlus implements OperationProcessorInterface
     use OperandHelper;
     use OperatorCalculatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptRegexpmatch2.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptRegexpmatch2.php
index 0c8e65ed..174ec885 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptRegexpmatch2.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptRegexpmatch2.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -14,11 +14,11 @@
 class BuiltinOptRegexpmatch2 implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptReverse.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptReverse.php
index b4c33e1a..0518fe3d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptReverse.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptReverse.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinOptReverse implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSendWithoutBlock.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSendWithoutBlock.php
index c2d34c6a..2f43f227 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSendWithoutBlock.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSendWithoutBlock.php
@@ -6,7 +6,7 @@
 
 use RubyVM\VM\Core\Runtime\Executor\ArgumentTransformable;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -20,11 +20,11 @@ class BuiltinOptSendWithoutBlock implements OperationProcessorInterface
     use ArgumentTransformable;
     use Sender;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSize.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSize.php
index 4876196a..e2c82d89 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSize.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSize.php
@@ -8,7 +8,7 @@
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Comparable\Integer_;
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Enumerable\Array_;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -18,11 +18,11 @@
 class BuiltinOptSize implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrFreeze.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrFreeze.php
index ee2d9450..b6523d14 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrFreeze.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrFreeze.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinOptStrFreeze implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrUminus.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrUminus.php
index eb6a5ca5..17a5b1f1 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrUminus.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrUminus.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinOptStrUminus implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSucc.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSucc.php
index a5149ec7..81fad812 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSucc.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSucc.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinOptSucc implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPop.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPop.php
index 221d8397..af38486e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPop.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPop.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -16,11 +16,11 @@ class BuiltinPop implements OperationProcessorInterface
     use OperandHelper;
     use Validatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutnil.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutnil.php
index 2c3f5f02..35e9fbca 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutnil.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutnil.php
@@ -6,7 +6,7 @@
 
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\NilClass;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -15,11 +15,11 @@
 class BuiltinPutnil implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutobject.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutobject.php
index f7627ee2..5198a291 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutobject.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutobject.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -17,11 +17,11 @@ class BuiltinPutobject implements OperationProcessorInterface
     use OperandHelper;
     use Validatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutobjectINT2FIX0.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutobjectINT2FIX0.php
index bdad68bd..d8ce686f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutobjectINT2FIX0.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutobjectINT2FIX0.php
@@ -6,7 +6,7 @@
 
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Comparable\Integer_;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -15,11 +15,11 @@
 class BuiltinPutobjectINT2FIX0 implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutobjectINT2FIX1.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutobjectINT2FIX1.php
index 54e36a6d..c93b6919 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutobjectINT2FIX1.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutobjectINT2FIX1.php
@@ -6,7 +6,7 @@
 
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Comparable\Integer_;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -15,11 +15,11 @@
 class BuiltinPutobjectINT2FIX1 implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutself.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutself.php
index 4576178b..96eebdc6 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutself.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutself.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -14,11 +14,11 @@
 class BuiltinPutself implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutspecialobject.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutspecialobject.php
index 8eff4153..636ec8b2 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutspecialobject.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutspecialobject.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -18,11 +18,11 @@ class BuiltinPutspecialobject implements OperationProcessorInterface
     use OperandHelper;
     use Validatable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutstring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutstring.php
index b284d8c4..156627d6 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutstring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinPutstring.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -13,11 +13,11 @@
 class BuiltinPutstring implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSend.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSend.php
index b7dc2ef2..adb2bd68 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSend.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSend.php
@@ -6,7 +6,7 @@
 
 use RubyVM\VM\Core\Runtime\Executor\ArgumentTransformable;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -20,11 +20,11 @@ class BuiltinSend implements OperationProcessorInterface
     use ArgumentTransformable;
     use Sender;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetblockparam.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetblockparam.php
index 82520530..9c935f2d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetblockparam.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetblockparam.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinSetblockparam implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetclassvariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetclassvariable.php
index 887f9245..51aeab2d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetclassvariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetclassvariable.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinSetclassvariable implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetconstant.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetconstant.php
index e4567c88..6d678ef2 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetconstant.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetconstant.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinSetconstant implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetglobal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetglobal.php
index 2044e59f..f2eb0de7 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetglobal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetglobal.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -13,11 +13,11 @@
 class BuiltinSetglobal implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetinstancevariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetinstancevariable.php
index 610c79a4..2a99d3ed 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetinstancevariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetinstancevariable.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -13,11 +13,11 @@
 class BuiltinSetinstancevariable implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetlocal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetlocal.php
index e90a1690..4e7db196 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetlocal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetlocal.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\LocalTable;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -15,11 +15,11 @@ class BuiltinSetlocal implements OperationProcessorInterface
 {
     use LocalTable;
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetlocalWC0.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetlocalWC0.php
index a2d82d13..b6568f3f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetlocalWC0.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetlocalWC0.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\LocalTable;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -18,11 +18,11 @@ class BuiltinSetlocalWC0 implements OperationProcessorInterface
     use Validatable;
     use LocalTable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetlocalWC1.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetlocalWC1.php
index 6ebf97b2..bc9f9a1a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetlocalWC1.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetlocalWC1.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\LocalTable;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -16,11 +16,11 @@ class BuiltinSetlocalWC1 implements OperationProcessorInterface
     use OperandHelper;
     use LocalTable;
 
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetn.php
index 5d09a438..59692585 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetn.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinSetn implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetspecial.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetspecial.php
index 4e201596..4ee186e4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetspecial.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetspecial.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinSetspecial implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSplatarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSplatarray.php
index af1042ea..93e4537e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSplatarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSplatarray.php
@@ -6,7 +6,7 @@
 
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Enumerable\Array_;
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
@@ -15,11 +15,11 @@
 class BuiltinSplatarray implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSwap.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSwap.php
index a5b1c679..ea9672ba 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSwap.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSwap.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinSwap implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinThrow.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinThrow.php
index c9f7df26..8e5ff2b6 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinThrow.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinThrow.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinThrow implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTopn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTopn.php
index d5bf4302..dffe27af 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTopn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTopn.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTopn implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinToregexp.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinToregexp.php
index 838d49c7..a2b67bef 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinToregexp.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinToregexp.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinToregexp implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAdjuststack.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAdjuststack.php
index 6b0c78cb..8107aad7 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAdjuststack.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAdjuststack.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceAdjuststack implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAnytostring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAnytostring.php
index dcc21fc2..7870f538 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAnytostring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAnytostring.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceAnytostring implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchif.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchif.php
index 4df6d55d..bd10dd87 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchif.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchif.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceBranchif implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchnil.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchnil.php
index cd48c672..451e36bc 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchnil.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchnil.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceBranchnil implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchunless.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchunless.php
index bd88b870..472c4899 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchunless.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchunless.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceBranchunless implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckkeyword.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckkeyword.php
index 56d77c72..c940e317 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckkeyword.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckkeyword.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceCheckkeyword implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckmatch.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckmatch.php
index 9dd7f364..62828bcc 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckmatch.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckmatch.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceCheckmatch implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceChecktype.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceChecktype.php
index 69aec7f1..5ba1f661 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceChecktype.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceChecktype.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceChecktype implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatarray.php
index 4daa3d9b..8722bf7e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatarray.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceConcatarray implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatstrings.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatstrings.php
index f32b9322..77fbe8f4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatstrings.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatstrings.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceConcatstrings implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefineclass.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefineclass.php
index 387c0889..e4020f89 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefineclass.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefineclass.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceDefineclass implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefined.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefined.php
index 910e735b..453ddaf0 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefined.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefined.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceDefined implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinemethod.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinemethod.php
index 7943f2b9..5494ab4b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinemethod.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinemethod.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceDefinemethod implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinesmethod.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinesmethod.php
index df00ffa3..7ad5d819 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinesmethod.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinesmethod.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceDefinesmethod implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDup.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDup.php
index c9a2400d..ff2a868a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDup.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDup.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceDup implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuparray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuparray.php
index 30dae9a5..60b1c956 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuparray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuparray.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceDuparray implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuphash.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuphash.php
index 5e16d1e0..6badab7e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuphash.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuphash.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceDuphash implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDupn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDupn.php
index 87109562..a672809c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDupn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDupn.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceDupn implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceExpandarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceExpandarray.php
index 75c234db..91dce0be 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceExpandarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceExpandarray.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceExpandarray implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php
index dde07197..f6b3d613 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceGetblockparam implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparamproxy.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparamproxy.php
index 598b5c91..ab9eeb49 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparamproxy.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparamproxy.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceGetblockparamproxy implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetclassvariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetclassvariable.php
index 5efe99a7..c7ffaf18 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetclassvariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetclassvariable.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceGetclassvariable implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetconstant.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetconstant.php
index 7fa007cc..42a0e91e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetconstant.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetconstant.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceGetconstant implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetglobal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetglobal.php
index 0e43423f..18e09904 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetglobal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetglobal.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceGetglobal implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetinstancevariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetinstancevariable.php
index ea833008..08b24536 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetinstancevariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetinstancevariable.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceGetinstancevariable implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocal.php
index 85f17c4e..d9f3f31d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocal.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceGetlocal implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC0.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC0.php
index efe9163d..3f9cd3eb 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC0.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC0.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceGetlocalWC0 implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC1.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC1.php
index c8c09829..e3157d95 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC1.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC1.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceGetlocalWC1 implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetspecial.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetspecial.php
index d173620d..ef208b0f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetspecial.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetspecial.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceGetspecial implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceIntern.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceIntern.php
index 60e9fc34..9404a8b0 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceIntern.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceIntern.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceIntern implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokeblock.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokeblock.php
index 8bcb6d0a..e71b3a24 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokeblock.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokeblock.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceInvokeblock implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokebuiltin.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokebuiltin.php
index 7e2152db..377ec042 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokebuiltin.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokebuiltin.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceInvokebuiltin implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokesuper.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokesuper.php
index 2e19291a..5ede9fb9 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokesuper.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokesuper.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceInvokesuper implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceJump.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceJump.php
index b6fa0038..0b74c14b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceJump.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceJump.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceJump implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceLeave.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceLeave.php
index f699cc15..d7682bf2 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceLeave.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceLeave.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceLeave implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarray.php
index 1d473b3e..6ca9ef8c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarray.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceNewarray implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarraykwsplat.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarraykwsplat.php
index a911e9ce..3c89c438 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarraykwsplat.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarraykwsplat.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceNewarraykwsplat implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewhash.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewhash.php
index 07b10f87..0d2950dc 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewhash.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewhash.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceNewhash implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewrange.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewrange.php
index f91a7265..109fba8e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewrange.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewrange.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceNewrange implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNop.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNop.php
index 14338bbd..33894204 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNop.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNop.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceNop implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceObjtostring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceObjtostring.php
index 32d58326..0c196278 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceObjtostring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceObjtostring.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceObjtostring implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOnce.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOnce.php
index 205d156e..10f19586 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOnce.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOnce.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOnce implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAnd.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAnd.php
index 4d371011..b0915ed4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAnd.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAnd.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptAnd implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAref.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAref.php
index 29ce036c..e25a013f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAref.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAref.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptAref implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptArefWith.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptArefWith.php
index ead45cd6..dae97934 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptArefWith.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptArefWith.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptArefWith implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAset.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAset.php
index 146384ee..e696740c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAset.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAset.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptAset implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAsetWith.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAsetWith.php
index d11a6df0..9106aa11 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAsetWith.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAsetWith.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptAsetWith implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptCaseDispatch.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptCaseDispatch.php
index f36afdae..1bb6cbcd 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptCaseDispatch.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptCaseDispatch.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptCaseDispatch implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptDiv.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptDiv.php
index 25d3a2c0..e71f51d1 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptDiv.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptDiv.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptDiv implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEmptyP.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEmptyP.php
index c2a7b0aa..73a1dff5 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEmptyP.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEmptyP.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptEmptyP implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEq.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEq.php
index 7f133af0..ce72aa5b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEq.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEq.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptEq implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGe.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGe.php
index b6c5f0d9..cf1bdf22 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGe.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGe.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptGe implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGetconstantPath.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGetconstantPath.php
index aef754a2..025045cc 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGetconstantPath.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGetconstantPath.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptGetconstantPath implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGt.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGt.php
index 54cfe4c0..431b6d8f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGt.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGt.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptGt implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegate.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegate.php
index 951f14e1..dbc5ccc4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegate.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegate.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptInvokebuiltinDelegate implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegateLeave.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegateLeave.php
index 41b8895d..0b9c50c7 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegateLeave.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegateLeave.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptInvokebuiltinDelegateLeave implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLe.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLe.php
index 9961d0b0..9337c95f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLe.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLe.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptLe implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLength.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLength.php
index 0b7f5f8f..c4cbac19 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLength.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLength.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptLength implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLt.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLt.php
index cb47319a..d2912bff 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLt.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLt.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptLt implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLtlt.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLtlt.php
index c706b4a9..74bb7d39 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLtlt.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLtlt.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptLtlt implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMinus.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMinus.php
index 5d0bf2ba..ccc4f0d1 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMinus.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMinus.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptMinus implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMod.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMod.php
index cd9ec793..db289dba 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMod.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMod.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptMod implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMult.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMult.php
index 02979a15..f5976531 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMult.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMult.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptMult implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNeq.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNeq.php
index 2629d3ba..428d3a91 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNeq.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNeq.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptNeq implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMax.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMax.php
index 0dcd8218..e681455e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMax.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMax.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptNewarrayMax implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMin.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMin.php
index 13a3b33a..af6163b4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMin.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMin.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptNewarrayMin implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNilP.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNilP.php
index 19b16e73..dc6b9d1c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNilP.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNilP.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptNilP implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNot.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNot.php
index f2429b10..12b040c2 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNot.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNot.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptNot implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptOr.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptOr.php
index 3cef29f3..f4393907 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptOr.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptOr.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptOr implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptPlus.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptPlus.php
index 12c01338..889baa3d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptPlus.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptPlus.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptPlus implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptRegexpmatch2.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptRegexpmatch2.php
index 01097280..5fc47753 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptRegexpmatch2.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptRegexpmatch2.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptRegexpmatch2 implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptReverse.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptReverse.php
index b34af0d8..26668a3c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptReverse.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptReverse.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptReverse implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSendWithoutBlock.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSendWithoutBlock.php
index bf3c0c61..664288ca 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSendWithoutBlock.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSendWithoutBlock.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptSendWithoutBlock implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSize.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSize.php
index 7b80980d..fec9f06c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSize.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSize.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptSize implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrFreeze.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrFreeze.php
index 829cffe1..379250e5 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrFreeze.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrFreeze.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptStrFreeze implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrUminus.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrUminus.php
index 3d4a4de4..98be6cf4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrUminus.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrUminus.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptStrUminus implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSucc.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSucc.php
index 53420d49..1a9d861a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSucc.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSucc.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceOptSucc implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePop.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePop.php
index 395a302c..2156c49c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePop.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePop.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTracePop implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutnil.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutnil.php
index 4efabb57..fe133f65 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutnil.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutnil.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTracePutnil implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobject.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobject.php
index 17ea6a84..7b13b0cc 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobject.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobject.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTracePutobject implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX0.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX0.php
index e68312d6..365cc0db 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX0.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX0.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTracePutobjectINT2FIX0 implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX1.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX1.php
index a1e07845..e104afda 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX1.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX1.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTracePutobjectINT2FIX1 implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutself.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutself.php
index c16d2959..860fd66c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutself.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutself.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTracePutself implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutspecialobject.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutspecialobject.php
index 4e0d1fe1..7549bc76 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutspecialobject.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutspecialobject.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTracePutspecialobject implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutstring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutstring.php
index 4c87da61..19fad09d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutstring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutstring.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTracePutstring implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSend.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSend.php
index 2dc5b621..11de9c32 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSend.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSend.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceSend implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetblockparam.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetblockparam.php
index e62a23c2..c5ac3676 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetblockparam.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetblockparam.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceSetblockparam implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetclassvariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetclassvariable.php
index a50e1ed4..2cbeb42b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetclassvariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetclassvariable.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceSetclassvariable implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetconstant.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetconstant.php
index 39594990..854e396a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetconstant.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetconstant.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceSetconstant implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetglobal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetglobal.php
index 66433f6e..30211f08 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetglobal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetglobal.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceSetglobal implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetinstancevariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetinstancevariable.php
index 87c07a2d..1148e427 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetinstancevariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetinstancevariable.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceSetinstancevariable implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocal.php
index b3339cec..3f78ae4a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocal.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceSetlocal implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC0.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC0.php
index 90f9214a..ee338b7b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC0.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC0.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceSetlocalWC0 implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC1.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC1.php
index 66834cdd..f2b77ff4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC1.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC1.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceSetlocalWC1 implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetn.php
index c0fee36f..310891e4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetn.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceSetn implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetspecial.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetspecial.php
index 20895e2f..7c6c8128 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetspecial.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetspecial.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceSetspecial implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSplatarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSplatarray.php
index 4103ed0a..90053827 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSplatarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSplatarray.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceSplatarray implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSwap.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSwap.php
index af466625..6cafc63f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSwap.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSwap.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceSwap implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceThrow.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceThrow.php
index 8c61ae21..473f1f84 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceThrow.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceThrow.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceThrow implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceTopn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceTopn.php
index 10768abb..78c515b4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceTopn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceTopn.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceTopn implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceToregexp.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceToregexp.php
index c2fb1bef..9f87bded 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceToregexp.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceToregexp.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Insn\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\OperandHelper;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
@@ -14,11 +14,11 @@
 class BuiltinTraceToregexp implements OperationProcessorInterface
 {
     use OperandHelper;
-    private Insn $insn;
+    private InsnInterface $insn;
 
     private ContextInterface $context;
 
-    public function prepare(Insn $insn, ContextInterface $context): void
+    public function prepare(InsnInterface $insn, ContextInterface $context): void
     {
         $this->insn = $insn;
         $this->context = $context;
diff --git a/src/VM/Core/Runtime/Executor/Operation/Operation.php b/src/VM/Core/Runtime/Executor/Operation/Operation.php
index 1935c718..b9352486 100644
--- a/src/VM/Core/Runtime/Executor/Operation/Operation.php
+++ b/src/VM/Core/Runtime/Executor/Operation/Operation.php
@@ -4,11 +4,11 @@
 
 namespace RubyVM\VM\Core\Runtime\Executor\Operation;
 
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 
 class Operation
 {
     public function __construct(
-        public readonly Insn $insn,
+        public readonly InsnInterface $insn,
     ) {}
 }
diff --git a/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorEntries.php b/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorEntries.php
index 55096739..5723639f 100644
--- a/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorEntries.php
+++ b/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorEntries.php
@@ -5,7 +5,7 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Operation\Processor;
 
 use RubyVM\VM\Core\Criterion\Entry\AbstractEntries;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Exception\OperationProcessorException;
 
 class OperationProcessorEntries extends AbstractEntries
@@ -17,12 +17,12 @@ public function verify(mixed $value): bool
 
     public function verifyOffset(mixed $key): bool
     {
-        return $key instanceof Insn;
+        return $key instanceof InsnInterface;
     }
 
     public function get(mixed $index): OperationProcessorInterface
     {
-        if (!$index instanceof Insn) {
+        if (!$index instanceof InsnInterface) {
             throw new OperationProcessorException('The passed index is not instantiated by an Insn enum - you should to specify parameter with instantiated by Insn enum');
         }
 
diff --git a/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorInterface.php b/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorInterface.php
index bc803fa4..6746b9cb 100644
--- a/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorInterface.php
+++ b/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorInterface.php
@@ -5,12 +5,12 @@
 namespace RubyVM\VM\Core\Runtime\Executor\Operation\Processor;
 
 use RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\ProcessedStatus;
 
 interface OperationProcessorInterface
 {
-    public function prepare(Insn $insn, ContextInterface $context): void;
+    public function prepare(InsnInterface $insn, ContextInterface $context): void;
 
     public function before(): void;
 
diff --git a/src/VM/Core/Runtime/Executor/Insn/Insn.php b/src/VM/Core/Runtime/Kernel/Ruby3_2/InstructionSequence/Insn.php
similarity index 97%
rename from src/VM/Core/Runtime/Executor/Insn/Insn.php
rename to src/VM/Core/Runtime/Kernel/Ruby3_2/InstructionSequence/Insn.php
index c6f22cd1..0fe33ba9 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Insn.php
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_2/InstructionSequence/Insn.php
@@ -2,11 +2,12 @@
 
 declare(strict_types=1);
 
-namespace RubyVM\VM\Core\Runtime\Executor\Insn;
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_2\InstructionSequence;
 
 use RubyVM\VM\Core\Helper\EnumIntValueFindable;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 
-enum Insn: int
+enum Insn: int implements InsnInterface
 {
     use EnumIntValueFindable;
 
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_2/InstructionSequence/InstructionSequenceProcessor.php b/src/VM/Core/Runtime/Kernel/Ruby3_2/InstructionSequence/InstructionSequenceProcessor.php
index c1aac22b..43cc46cc 100644
--- a/src/VM/Core/Runtime/Kernel/Ruby3_2/InstructionSequence/InstructionSequenceProcessor.php
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_2/InstructionSequence/InstructionSequenceProcessor.php
@@ -8,7 +8,6 @@
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Offset;
 use RubyVM\VM\Core\Runtime\ClassCreator;
 use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
 use RubyVM\VM\Core\Runtime\Executor\Insn\InsnType;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operation;
diff --git a/src/VM/Core/Runtime/Executor/Operation/DefaultOperationProcessorEntries.php b/src/VM/Core/Runtime/Kernel/Ruby3_2/InstructionSequence/OperationProcessorEntries.php
similarity index 99%
rename from src/VM/Core/Runtime/Executor/Operation/DefaultOperationProcessorEntries.php
rename to src/VM/Core/Runtime/Kernel/Ruby3_2/InstructionSequence/OperationProcessorEntries.php
index 700b0465..815c8028 100644
--- a/src/VM/Core/Runtime/Executor/Operation/DefaultOperationProcessorEntries.php
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_2/InstructionSequence/OperationProcessorEntries.php
@@ -2,9 +2,8 @@
 
 declare(strict_types=1);
 
-namespace RubyVM\VM\Core\Runtime\Executor\Operation;
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_2\InstructionSequence;
 
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinAdjuststack;
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinAnytostring;
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinBranchif;
@@ -207,9 +206,9 @@
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceThrow;
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceTopn;
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceToregexp;
-use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorEntries;
+use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorEntries as BaseOperationProcessorEntries;
 
-class DefaultOperationProcessorEntries extends OperationProcessorEntries
+class OperationProcessorEntries extends BaseOperationProcessorEntries
 {
     public function __construct(array $items = [])
     {
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_2/Kernel.php b/src/VM/Core/Runtime/Kernel/Ruby3_2/Kernel.php
index e0161386..35eea5fb 100644
--- a/src/VM/Core/Runtime/Kernel/Ruby3_2/Kernel.php
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_2/Kernel.php
@@ -20,6 +20,7 @@
 
 use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
 use RubyVM\VM\Core\Runtime\Essential\RubyVMInterface;
+use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorEntries;
 use RubyVM\VM\Core\Runtime\Kernel\Ruby3_2\HeapSpace\DefaultInstanceHeapSpace;
 use RubyVM\VM\Core\Runtime\Kernel\Ruby3_2\InstructionSequence\InstructionSequenceProcessor;
 use RubyVM\VM\Core\Runtime\Kernel\Ruby3_2\Loader\ArraySymbolLoader;
@@ -223,7 +224,7 @@ public function findId(int $index): ID
     public function findObject(int $index): SymbolInterface
     {
         if (!isset($this->globalObjectList[$index])) {
-            throw new RubyVMException(sprintf('Cannot resolve to refer index#%d in the global object list', $index));
+            throw new RubyVMException(sprintf('Cannot resolve to refer index#%din the global object list', $index));
         }
 
         $this->vm->option()->logger->info(
@@ -380,4 +381,10 @@ public function instructionSequenceList(): Offsets
     {
         return $this->instructionSequenceList;
     }
+
+    public function operationProcessorEntries(): OperationProcessorEntries
+    {
+        static $entries;
+        return $entries ??= new \RubyVM\VM\Core\Runtime\Kernel\Ruby3_2\InstructionSequence\OperationProcessorEntries();
+    }
 }
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Insn.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Insn.php
new file mode 100644
index 00000000..7bc667c4
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Insn.php
@@ -0,0 +1,218 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence;
+
+use RubyVM\VM\Core\Helper\EnumIntValueFindable;
+use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
+
+enum Insn: int implements InsnInterface
+{
+    use EnumIntValueFindable;
+
+    case NOP = 0;
+    case GETLOCAL = 1;
+    case SETLOCAL = 2;
+    case GETBLOCKPARAM = 3;
+    case SETBLOCKPARAM = 4;
+    case GETBLOCKPARAMPROXY = 5;
+    case GETSPECIAL = 6;
+    case SETSPECIAL = 7;
+    case GETINSTANCEVARIABLE = 8;
+    case SETINSTANCEVARIABLE = 9;
+    case GETCLASSVARIABLE = 10;
+    case SETCLASSVARIABLE = 11;
+    case OPT_GETCONSTANT_PATH = 12;
+    case GETCONSTANT = 13;
+    case SETCONSTANT = 14;
+    case GETGLOBAL = 15;
+    case SETGLOBAL = 16;
+    case PUTNIL = 17;
+    case PUTSELF = 18;
+    case PUTOBJECT = 19;
+    case PUTSPECIALOBJECT = 20;
+    case PUTSTRING = 21;
+    case CONCATSTRINGS = 22;
+    case ANYTOSTRING = 23;
+    case TOREGEXP = 24;
+    case INTERN = 25;
+    case NEWARRAY = 26;
+    case NEWARRAYKWSPLAT = 27;
+    case DUPARRAY = 28;
+    case DUPHASH = 29;
+    case EXPANDARRAY = 30;
+    case CONCATARRAY = 31;
+    case SPLATARRAY = 32;
+    case SPLATKW = 33;
+    case NEWHASH = 34;
+    case NEWRANGE = 35;
+    case POP = 36;
+    case DUP = 37;
+    case DUPN = 38;
+    case SWAP = 39;
+    case OPT_REVERSE = 40;
+    case TOPN = 41;
+    case SETN = 42;
+    case ADJUSTSTACK = 43;
+    case DEFINED = 44;
+    case DEFINEDIVAR = 45;
+    case CHECKMATCH = 46;
+    case CHECKKEYWORD = 47;
+    case CHECKTYPE = 48;
+    case DEFINECLASS = 49;
+    case DEFINEMETHOD = 50;
+    case DEFINESMETHOD = 51;
+    case SEND = 52;
+    case OPT_SEND_WITHOUT_BLOCK = 53;
+    case OBJTOSTRING = 54;
+    case OPT_STR_FREEZE = 55;
+    case OPT_NIL_P = 56;
+    case OPT_STR_UMINUS = 57;
+    case OPT_NEWARRAY_SEND = 58;
+    case INVOKESUPER = 59;
+    case INVOKEBLOCK = 60;
+    case LEAVE = 61;
+    case THROW = 62;
+    case JUMP = 63;
+    case BRANCHIF = 64;
+    case BRANCHUNLESS = 65;
+    case BRANCHNIL = 66;
+    case ONCE = 67;
+    case OPT_CASE_DISPATCH = 68;
+    case OPT_PLUS = 69;
+    case OPT_MINUS = 70;
+    case OPT_MULT = 71;
+    case OPT_DIV = 72;
+    case OPT_MOD = 73;
+    case OPT_EQ = 74;
+    case OPT_NEQ = 75;
+    case OPT_LT = 76;
+    case OPT_LE = 77;
+    case OPT_GT = 78;
+    case OPT_GE = 79;
+    case OPT_LTLT = 80;
+    case OPT_AND = 81;
+    case OPT_OR = 82;
+    case OPT_AREF = 83;
+    case OPT_ASET = 84;
+    case OPT_ASET_WITH = 85;
+    case OPT_AREF_WITH = 86;
+    case OPT_LENGTH = 87;
+    case OPT_SIZE = 88;
+    case OPT_EMPTY_P = 89;
+    case OPT_SUCC = 90;
+    case OPT_NOT = 91;
+    case OPT_REGEXPMATCH2 = 92;
+    case INVOKEBUILTIN = 93;
+    case OPT_INVOKEBUILTIN_DELEGATE = 94;
+    case OPT_INVOKEBUILTIN_DELEGATE_LEAVE = 95;
+    case GETLOCAL_WC_0 = 96;
+    case GETLOCAL_WC_1 = 97;
+    case SETLOCAL_WC_0 = 98;
+    case SETLOCAL_WC_1 = 99;
+    case PUTOBJECT_INT2FIX_0_ = 100;
+    case PUTOBJECT_INT2FIX_1_ = 101;
+    case TRACE_NOP = 102;
+    case TRACE_GETLOCAL = 103;
+    case TRACE_SETLOCAL = 104;
+    case TRACE_GETBLOCKPARAM = 105;
+    case TRACE_SETBLOCKPARAM = 106;
+    case TRACE_GETBLOCKPARAMPROXY = 107;
+    case TRACE_GETSPECIAL = 108;
+    case TRACE_SETSPECIAL = 109;
+    case TRACE_GETINSTANCEVARIABLE = 110;
+    case TRACE_SETINSTANCEVARIABLE = 111;
+    case TRACE_GETCLASSVARIABLE = 112;
+    case TRACE_SETCLASSVARIABLE = 113;
+    case TRACE_OPT_GETCONSTANT_PATH = 114;
+    case TRACE_GETCONSTANT = 115;
+    case TRACE_SETCONSTANT = 116;
+    case TRACE_GETGLOBAL = 117;
+    case TRACE_SETGLOBAL = 118;
+    case TRACE_PUTNIL = 119;
+    case TRACE_PUTSELF = 120;
+    case TRACE_PUTOBJECT = 121;
+    case TRACE_PUTSPECIALOBJECT = 122;
+    case TRACE_PUTSTRING = 123;
+    case TRACE_CONCATSTRINGS = 124;
+    case TRACE_ANYTOSTRING = 125;
+    case TRACE_TOREGEXP = 126;
+    case TRACE_INTERN = 127;
+    case TRACE_NEWARRAY = 128;
+    case TRACE_NEWARRAYKWSPLAT = 129;
+    case TRACE_DUPARRAY = 130;
+    case TRACE_DUPHASH = 131;
+    case TRACE_EXPANDARRAY = 132;
+    case TRACE_CONCATARRAY = 133;
+    case TRACE_SPLATARRAY = 134;
+    case TRACE_SPLATKW = 135;
+    case TRACE_NEWHASH = 136;
+    case TRACE_NEWRANGE = 137;
+    case TRACE_POP = 138;
+    case TRACE_DUP = 139;
+    case TRACE_DUPN = 140;
+    case TRACE_SWAP = 141;
+    case TRACE_OPT_REVERSE = 142;
+    case TRACE_TOPN = 143;
+    case TRACE_SETN = 144;
+    case TRACE_ADJUSTSTACK = 145;
+    case TRACE_DEFINED = 146;
+    case TRACE_DEFINEDIVAR = 147;
+    case TRACE_CHECKMATCH = 148;
+    case TRACE_CHECKKEYWORD = 149;
+    case TRACE_CHECKTYPE = 150;
+    case TRACE_DEFINECLASS = 151;
+    case TRACE_DEFINEMETHOD = 152;
+    case TRACE_DEFINESMETHOD = 153;
+    case TRACE_SEND = 154;
+    case TRACE_OPT_SEND_WITHOUT_BLOCK = 155;
+    case TRACE_OBJTOSTRING = 156;
+    case TRACE_OPT_STR_FREEZE = 157;
+    case TRACE_OPT_NIL_P = 158;
+    case TRACE_OPT_STR_UMINUS = 159;
+    case TRACE_OPT_NEWARRAY_SEND = 160;
+    case TRACE_INVOKESUPER = 161;
+    case TRACE_INVOKEBLOCK = 162;
+    case TRACE_LEAVE = 163;
+    case TRACE_THROW = 164;
+    case TRACE_JUMP = 165;
+    case TRACE_BRANCHIF = 166;
+    case TRACE_BRANCHUNLESS = 167;
+    case TRACE_BRANCHNIL = 168;
+    case TRACE_ONCE = 169;
+    case TRACE_OPT_CASE_DISPATCH = 170;
+    case TRACE_OPT_PLUS = 171;
+    case TRACE_OPT_MINUS = 172;
+    case TRACE_OPT_MULT = 173;
+    case TRACE_OPT_DIV = 174;
+    case TRACE_OPT_MOD = 175;
+    case TRACE_OPT_EQ = 176;
+    case TRACE_OPT_NEQ = 177;
+    case TRACE_OPT_LT = 178;
+    case TRACE_OPT_LE = 179;
+    case TRACE_OPT_GT = 180;
+    case TRACE_OPT_GE = 181;
+    case TRACE_OPT_LTLT = 182;
+    case TRACE_OPT_AND = 183;
+    case TRACE_OPT_OR = 184;
+    case TRACE_OPT_AREF = 185;
+    case TRACE_OPT_ASET = 186;
+    case TRACE_OPT_ASET_WITH = 187;
+    case TRACE_OPT_AREF_WITH = 188;
+    case TRACE_OPT_LENGTH = 189;
+    case TRACE_OPT_SIZE = 190;
+    case TRACE_OPT_EMPTY_P = 191;
+    case TRACE_OPT_SUCC = 192;
+    case TRACE_OPT_NOT = 193;
+    case TRACE_OPT_REGEXPMATCH2 = 194;
+    case TRACE_INVOKEBUILTIN = 195;
+    case TRACE_OPT_INVOKEBUILTIN_DELEGATE = 196;
+    case TRACE_OPT_INVOKEBUILTIN_DELEGATE_LEAVE = 197;
+    case TRACE_GETLOCAL_WC_0 = 198;
+    case TRACE_GETLOCAL_WC_1 = 199;
+    case TRACE_SETLOCAL_WC_0 = 200;
+    case TRACE_SETLOCAL_WC_1 = 201;
+    case TRACE_PUTOBJECT_INT2FIX_0_ = 202;
+    case TRACE_PUTOBJECT_INT2FIX_1_ = 203;
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceProcessor.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceProcessor.php
index 027b704f..5e5103b9 100644
--- a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceProcessor.php
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceProcessor.php
@@ -8,7 +8,6 @@
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Offset;
 use RubyVM\VM\Core\Runtime\ClassCreator;
 use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
 use RubyVM\VM\Core\Runtime\Executor\Insn\InsnType;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operation;
@@ -491,47 +490,47 @@ private function processInlineCache(int $value): ID
     private function insnOperationsOperands(): array
     {
         return [
-            '',     "\0", 'LN',   "\0", 'LN',   "\0", 'LN',   "\0", 'LN',   "\0",
-            'LN',   "\0", 'NN',   "\0", 'N',    "\0", 'IA',   "\0", 'IA',   "\0",
-            'IJ',   "\0", 'IJ',   "\0", 'K',    "\0", 'I',    "\0", 'I',    "\0",
-            'I',    "\0", 'I',    "\0", '',     "\0", '',     "\0", 'V',    "\0",
-            'N',    "\0", 'V',    "\0", 'N',    "\0", '',     "\0", 'NN',   "\0",
-            '',     "\0", 'N',    "\0", 'N',    "\0", 'V',    "\0", 'V',    "\0",
-            'NN',   "\0", '',     "\0", 'V',    "\0", 'N',    "\0", 'N',    "\0",
-            '',     "\0", '',     "\0", 'N',    "\0", '',     "\0", 'N',    "\0",
-            'N',    "\0", 'N',    "\0", 'N',    "\0", 'NVV',  "\0", 'N',    "\0",
-            'LL',   "\0", 'N',    "\0", 'ISN',  "\0", 'IS',   "\0", 'IS',   "\0",
-            'CS',   "\0", 'C',    "\0", 'C',    "\0", 'VC',   "\0", 'C',    "\0",
-            'VC',   "\0", 'N',    "\0", 'N',    "\0", 'CS',   "\0", 'C',    "\0",
-            '',     "\0", 'N',    "\0", 'O',    "\0", 'O',    "\0", 'O',    "\0",
-            'O',    "\0", 'ST',   "\0", 'HO',   "\0", 'C',    "\0", 'C',    "\0",
-            'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'CC',   "\0",
-            'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
-            'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'VC',   "\0",
-            'VC',   "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
-            'C',    "\0", 'C',    "\0", 'R',    "\0", 'RN',   "\0", 'RN',   "\0",
-            'L',    "\0", 'L',    "\0", 'L',    "\0", 'L',    "\0", '',     "\0",
-            '',     "\0", '',     "\0", 'LN',   "\0", 'LN',   "\0", 'LN',   "\0",
-            'LN',   "\0", 'LN',   "\0", 'NN',   "\0", 'N',    "\0", 'IA',   "\0",
-            'IA',   "\0", 'IJ',   "\0", 'IJ',   "\0", 'K',    "\0", 'I',    "\0",
-            'I',    "\0", 'I',    "\0", 'I',    "\0", '',     "\0", '',     "\0",
-            'V',    "\0", 'N',    "\0", 'V',    "\0", 'N',    "\0", '',     "\0",
-            'NN',   "\0", '',     "\0", 'N',    "\0", 'N',    "\0", 'V',    "\0",
-            'V',    "\0", 'NN',   "\0", '',     "\0", 'V',    "\0", 'N',    "\0",
-            'N',    "\0", '',     "\0", '',     "\0", 'N',    "\0", '',     "\0",
-            'N',    "\0", 'N',    "\0", 'N',    "\0", 'N',    "\0", 'NVV',  "\0",
-            'N',    "\0", 'LL',   "\0", 'N',    "\0", 'ISN',  "\0", 'IS',   "\0",
-            'IS',   "\0", 'CS',   "\0", 'C',    "\0", 'C',    "\0", 'VC',   "\0",
-            'C',    "\0", 'VC',   "\0", 'N',    "\0", 'N',    "\0", 'CS',   "\0",
-            'C',    "\0", '',     "\0", 'N',    "\0", 'O',    "\0", 'O',    "\0",
-            'O',    "\0", 'O',    "\0", 'ST',   "\0", 'HO',   "\0", 'C',    "\0",
-            'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
-            'CC',   "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
-            'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
-            'VC',   "\0", 'VC',   "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
-            'C',    "\0", 'C',    "\0", 'C',    "\0", 'R',    "\0", 'RN',   "\0",
-            'RN',   "\0", 'L',    "\0", 'L',    "\0", 'L',    "\0", 'L',    "\0",
-            '',     "\0", '',     "\0",
+            "",     "\0", "LN",   "\0", "LN",   "\0", "LN",   "\0", "LN",   "\0",
+            "LN",   "\0", "NN",   "\0", "N",    "\0", "IA",   "\0", "IA",   "\0",
+            "IJ",   "\0", "IJ",   "\0", "K",    "\0", "I",    "\0", "I",    "\0",
+            "I",    "\0", "I",    "\0", "",     "\0", "",     "\0", "V",    "\0",
+            "N",    "\0", "V",    "\0", "N",    "\0", "",     "\0", "NN",   "\0",
+            "",     "\0", "N",    "\0", "N",    "\0", "V",    "\0", "V",    "\0",
+            "NN",   "\0", "",     "\0", "V",    "\0", "",     "\0", "N",    "\0",
+            "N",    "\0", "",     "\0", "",     "\0", "N",    "\0", "",     "\0",
+            "N",    "\0", "N",    "\0", "N",    "\0", "N",    "\0", "NVV",  "\0",
+            "IAV",  "\0", "N",    "\0", "LL",   "\0", "N",    "\0", "ISN",  "\0",
+            "IS",   "\0", "IS",   "\0", "CS",   "\0", "C",    "\0", "C",    "\0",
+            "VC",   "\0", "C",    "\0", "VC",   "\0", "NI",   "\0", "CS",   "\0",
+            "C",    "\0", "",     "\0", "N",    "\0", "O",    "\0", "O",    "\0",
+            "O",    "\0", "O",    "\0", "ST",   "\0", "HO",   "\0", "C",    "\0",
+            "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0",
+            "CC",   "\0", "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0",
+            "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0",
+            "VC",   "\0", "VC",   "\0", "C",    "\0", "C",    "\0", "C",    "\0",
+            "C",    "\0", "C",    "\0", "C",    "\0", "R",    "\0", "RN",   "\0",
+            "RN",   "\0", "L",    "\0", "L",    "\0", "L",    "\0", "L",    "\0",
+            "",     "\0", "",     "\0", "",     "\0", "LN",   "\0", "LN",   "\0",
+            "LN",   "\0", "LN",   "\0", "LN",   "\0", "NN",   "\0", "N",    "\0",
+            "IA",   "\0", "IA",   "\0", "IJ",   "\0", "IJ",   "\0", "K",    "\0",
+            "I",    "\0", "I",    "\0", "I",    "\0", "I",    "\0", "",     "\0",
+            "",     "\0", "V",    "\0", "N",    "\0", "V",    "\0", "N",    "\0",
+            "",     "\0", "NN",   "\0", "",     "\0", "N",    "\0", "N",    "\0",
+            "V",    "\0", "V",    "\0", "NN",   "\0", "",     "\0", "V",    "\0",
+            "",     "\0", "N",    "\0", "N",    "\0", "",     "\0", "",     "\0",
+            "N",    "\0", "",     "\0", "N",    "\0", "N",    "\0", "N",    "\0",
+            "N",    "\0", "NVV",  "\0", "IAV",  "\0", "N",    "\0", "LL",   "\0",
+            "N",    "\0", "ISN",  "\0", "IS",   "\0", "IS",   "\0", "CS",   "\0",
+            "C",    "\0", "C",    "\0", "VC",   "\0", "C",    "\0", "VC",   "\0",
+            "NI",   "\0", "CS",   "\0", "C",    "\0", "",     "\0", "N",    "\0",
+            "O",    "\0", "O",    "\0", "O",    "\0", "O",    "\0", "ST",   "\0",
+            "HO",   "\0", "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0",
+            "C",    "\0", "C",    "\0", "CC",   "\0", "C",    "\0", "C",    "\0",
+            "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0",
+            "C",    "\0", "C",    "\0", "VC",   "\0", "VC",   "\0", "C",    "\0",
+            "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0",
+            "R",    "\0", "RN",   "\0", "RN",   "\0", "L",    "\0", "L",    "\0",
+            "L",    "\0", "L",    "\0", "",     "\0", "",     "\0",
         ];
     }
 
@@ -543,21 +542,21 @@ private function insnOperationOperandsOffsets(): array
         return [
             0,   1,   4,   7,  10,  13,  16,  19,  21,  24,  27,  30,
             33,  35,  37,  39,  41,  43,  44,  45,  47,  49,  51,  53,
-            54,  57,  58,  60,  62,  64,  66,  69,  70,  72,  74,  76,
-            77,  78,  80,  81,  83,  85,  87,  89,  93,  95,  98, 100,
-            104, 107, 110, 113, 115, 117, 120, 122, 125, 127, 129, 132,
-            134, 135, 137, 139, 141, 143, 145, 148, 151, 153, 155, 157,
-            159, 161, 163, 166, 168, 170, 172, 174, 176, 178, 180, 182,
-            184, 187, 190, 192, 194, 196, 198, 200, 202, 204, 207, 210,
-            212, 214, 216, 218, 219, 220, 221, 224, 227, 230, 233, 236,
-            239, 241, 244, 247, 250, 253, 255, 257, 259, 261, 263, 264,
-            265, 267, 269, 271, 273, 274, 277, 278, 280, 282, 284, 286,
-            289, 290, 292, 294, 296, 297, 298, 300, 301, 303, 305, 307,
-            309, 313, 315, 318, 320, 324, 327, 330, 333, 335, 337, 340,
-            342, 345, 347, 349, 352, 354, 355, 357, 359, 361, 363, 365,
-            368, 371, 373, 375, 377, 379, 381, 383, 386, 388, 390, 392,
-            394, 396, 398, 400, 402, 404, 407, 410, 412, 414, 416, 418,
-            420, 422, 424, 427, 430, 432, 434, 436, 438, 439,
+            54,  57,  58,  60,  62,  64,  66,  69,  70,  72,  73,  75,
+            77,  78,  79,  81,  82,  84,  86,  88,  90,  94,  98, 100,
+            103, 105, 109, 112, 115, 118, 120, 122, 125, 127, 130, 133,
+            136, 138, 139, 141, 143, 145, 147, 149, 152, 155, 157, 159,
+            161, 163, 165, 167, 170, 172, 174, 176, 178, 180, 182, 184,
+            186, 188, 191, 194, 196, 198, 200, 202, 204, 206, 208, 211,
+            214, 216, 218, 220, 222, 223, 224, 225, 228, 231, 234, 237,
+            240, 243, 245, 248, 251, 254, 257, 259, 261, 263, 265, 267,
+            268, 269, 271, 273, 275, 277, 278, 281, 282, 284, 286, 288,
+            290, 293, 294, 296, 297, 299, 301, 302, 303, 305, 306, 308,
+            310, 312, 314, 318, 322, 324, 327, 329, 333, 336, 339, 342,
+            344, 346, 349, 351, 354, 357, 360, 362, 363, 365, 367, 369,
+            371, 373, 376, 379, 381, 383, 385, 387, 389, 391, 394, 396,
+            398, 400, 402, 404, 406, 408, 410, 412, 415, 418, 420, 422,
+            424, 426, 428, 430, 432, 435, 438, 440, 442, 444, 446, 447,
         ];
     }
 }
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/OperationProcessorEntries.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/OperationProcessorEntries.php
new file mode 100644
index 00000000..11da170f
--- /dev/null
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/OperationProcessorEntries.php
@@ -0,0 +1,415 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence;
+
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinAdjuststack;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinAnytostring;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinBranchif;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinBranchnil;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinBranchunless;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinCheckkeyword;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinCheckmatch;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinChecktype;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinConcatarray;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinConcatstrings;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinDefineclass;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinDefined;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinDefinemethod;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinDefinesmethod;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinDup;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinDuparray;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinDuphash;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinDupn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinExpandarray;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinGetblockparam;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinGetblockparamproxy;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinGetclassvariable;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinGetconstant;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinGetglobal;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinGetinstancevariable;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinGetlocal;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinGetlocalWC0;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinGetlocalWC1;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinGetspecial;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinIntern;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinInvokeblock;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinInvokebuiltin;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinInvokesuper;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinJump;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinLeave;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinNewarray;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinNewarraykwsplat;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinNewhash;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinNewrange;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinNop;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinObjtostring;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOnce;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptAnd;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptAref;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptArefWith;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptAset;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptAsetWith;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptCaseDispatch;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptDiv;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptEmptyP;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptEq;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptGe;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptGetconstantPath;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptGt;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptInvokebuiltinDelegate;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptInvokebuiltinDelegateLeave;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptLe;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptLength;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptLt;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptLtlt;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptMinus;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptMod;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptMult;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptNeq;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptNewarrayMax;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptNewarrayMin;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptNilP;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptNot;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptOr;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptPlus;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptRegexpmatch2;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptReverse;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptSendWithoutBlock;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptSize;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptStrFreeze;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptStrUminus;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptSucc;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinPop;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinPutnil;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinPutobject;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinPutobjectINT2FIX0;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinPutobjectINT2FIX1;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinPutself;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinPutspecialobject;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinPutstring;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinSend;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinSetblockparam;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinSetclassvariable;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinSetconstant;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinSetglobal;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinSetinstancevariable;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinSetlocal;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinSetlocalWC0;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinSetlocalWC1;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinSetn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinSetspecial;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinSplatarray;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinSwap;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinThrow;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTopn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinToregexp;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceAdjuststack;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceAnytostring;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceBranchif;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceBranchnil;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceBranchunless;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceCheckkeyword;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceCheckmatch;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceChecktype;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceConcatarray;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceConcatstrings;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceDefineclass;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceDefined;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceDefinemethod;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceDefinesmethod;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceDup;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceDuparray;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceDuphash;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceDupn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceExpandarray;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceGetblockparam;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceGetblockparamproxy;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceGetclassvariable;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceGetconstant;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceGetglobal;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceGetinstancevariable;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceGetlocal;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceGetlocalWC0;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceGetlocalWC1;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceGetspecial;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceIntern;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceInvokeblock;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceInvokebuiltin;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceInvokesuper;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceJump;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceLeave;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceNewarray;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceNewarraykwsplat;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceNewhash;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceNewrange;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceNop;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceObjtostring;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOnce;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptAnd;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptAref;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptArefWith;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptAset;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptAsetWith;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptCaseDispatch;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptDiv;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptEmptyP;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptEq;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptGe;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptGetconstantPath;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptGt;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptInvokebuiltinDelegate;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptInvokebuiltinDelegateLeave;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptLe;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptLength;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptLt;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptLtlt;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptMinus;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptMod;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptMult;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptNeq;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptNewarrayMax;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptNewarrayMin;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptNilP;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptNot;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptOr;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptPlus;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptRegexpmatch2;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptReverse;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptSendWithoutBlock;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptSize;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptStrFreeze;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptStrUminus;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptSucc;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTracePop;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTracePutnil;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTracePutobject;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTracePutobjectINT2FIX0;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTracePutobjectINT2FIX1;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTracePutself;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTracePutspecialobject;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTracePutstring;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceSend;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceSetblockparam;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceSetclassvariable;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceSetconstant;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceSetglobal;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceSetinstancevariable;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceSetlocal;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceSetlocalWC0;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceSetlocalWC1;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceSetn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceSetspecial;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceSplatarray;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceSwap;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceThrow;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceTopn;
+use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceToregexp;
+use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorEntries as BaseOperationProcessorEntries;
+
+class OperationProcessorEntries extends BaseOperationProcessorEntries
+{
+    public function __construct(array $items = [])
+    {
+        parent::__construct($items);
+        $this->set(Insn::NOP, new BuiltinNop());
+        $this->set(Insn::GETLOCAL, new BuiltinGetlocal());
+        $this->set(Insn::SETLOCAL, new BuiltinSetlocal());
+        $this->set(Insn::GETBLOCKPARAM, new BuiltinGetblockparam());
+        $this->set(Insn::SETBLOCKPARAM, new BuiltinSetblockparam());
+        $this->set(Insn::GETBLOCKPARAMPROXY, new BuiltinGetblockparamproxy());
+        $this->set(Insn::GETSPECIAL, new BuiltinGetspecial());
+        $this->set(Insn::SETSPECIAL, new BuiltinSetspecial());
+        $this->set(Insn::GETINSTANCEVARIABLE, new BuiltinGetinstancevariable());
+        $this->set(Insn::SETINSTANCEVARIABLE, new BuiltinSetinstancevariable());
+        $this->set(Insn::GETCLASSVARIABLE, new BuiltinGetclassvariable());
+        $this->set(Insn::SETCLASSVARIABLE, new BuiltinSetclassvariable());
+        $this->set(Insn::OPT_GETCONSTANT_PATH, new BuiltinOptGetconstantPath());
+        $this->set(Insn::GETCONSTANT, new BuiltinGetconstant());
+        $this->set(Insn::SETCONSTANT, new BuiltinSetconstant());
+        $this->set(Insn::GETGLOBAL, new BuiltinGetglobal());
+        $this->set(Insn::SETGLOBAL, new BuiltinSetglobal());
+        $this->set(Insn::PUTNIL, new BuiltinPutnil());
+        $this->set(Insn::PUTSELF, new BuiltinPutself());
+        $this->set(Insn::PUTOBJECT, new BuiltinPutobject());
+        $this->set(Insn::PUTSPECIALOBJECT, new BuiltinPutspecialobject());
+        $this->set(Insn::PUTSTRING, new BuiltinPutstring());
+        $this->set(Insn::CONCATSTRINGS, new BuiltinConcatstrings());
+        $this->set(Insn::ANYTOSTRING, new BuiltinAnytostring());
+        $this->set(Insn::TOREGEXP, new BuiltinToregexp());
+        $this->set(Insn::INTERN, new BuiltinIntern());
+        $this->set(Insn::NEWARRAY, new BuiltinNewarray());
+        $this->set(Insn::NEWARRAYKWSPLAT, new BuiltinNewarraykwsplat());
+        $this->set(Insn::DUPARRAY, new BuiltinDuparray());
+        $this->set(Insn::DUPHASH, new BuiltinDuphash());
+        $this->set(Insn::EXPANDARRAY, new BuiltinExpandarray());
+        $this->set(Insn::CONCATARRAY, new BuiltinConcatarray());
+        $this->set(Insn::SPLATARRAY, new BuiltinSplatarray());
+        $this->set(Insn::NEWHASH, new BuiltinNewhash());
+        $this->set(Insn::NEWRANGE, new BuiltinNewrange());
+        $this->set(Insn::POP, new BuiltinPop());
+        $this->set(Insn::DUP, new BuiltinDup());
+        $this->set(Insn::DUPN, new BuiltinDupn());
+        $this->set(Insn::SWAP, new BuiltinSwap());
+        $this->set(Insn::OPT_REVERSE, new BuiltinOptReverse());
+        $this->set(Insn::TOPN, new BuiltinTopn());
+        $this->set(Insn::SETN, new BuiltinSetn());
+        $this->set(Insn::ADJUSTSTACK, new BuiltinAdjuststack());
+        $this->set(Insn::DEFINED, new BuiltinDefined());
+        $this->set(Insn::CHECKMATCH, new BuiltinCheckmatch());
+        $this->set(Insn::CHECKKEYWORD, new BuiltinCheckkeyword());
+        $this->set(Insn::CHECKTYPE, new BuiltinChecktype());
+        $this->set(Insn::DEFINECLASS, new BuiltinDefineclass());
+        $this->set(Insn::DEFINEMETHOD, new BuiltinDefinemethod());
+        $this->set(Insn::DEFINESMETHOD, new BuiltinDefinesmethod());
+        $this->set(Insn::SEND, new BuiltinSend());
+        $this->set(Insn::OPT_SEND_WITHOUT_BLOCK, new BuiltinOptSendWithoutBlock());
+        $this->set(Insn::OBJTOSTRING, new BuiltinObjtostring());
+        $this->set(Insn::OPT_STR_FREEZE, new BuiltinOptStrFreeze());
+        $this->set(Insn::OPT_NIL_P, new BuiltinOptNilP());
+        $this->set(Insn::OPT_STR_UMINUS, new BuiltinOptStrUminus());
+        $this->set(Insn::INVOKESUPER, new BuiltinInvokesuper());
+        $this->set(Insn::INVOKEBLOCK, new BuiltinInvokeblock());
+        $this->set(Insn::LEAVE, new BuiltinLeave());
+        $this->set(Insn::THROW, new BuiltinThrow());
+        $this->set(Insn::JUMP, new BuiltinJump());
+        $this->set(Insn::BRANCHIF, new BuiltinBranchif());
+        $this->set(Insn::BRANCHUNLESS, new BuiltinBranchunless());
+        $this->set(Insn::BRANCHNIL, new BuiltinBranchnil());
+        $this->set(Insn::ONCE, new BuiltinOnce());
+        $this->set(Insn::OPT_CASE_DISPATCH, new BuiltinOptCaseDispatch());
+        $this->set(Insn::OPT_PLUS, new BuiltinOptPlus());
+        $this->set(Insn::OPT_MINUS, new BuiltinOptMinus());
+        $this->set(Insn::OPT_MULT, new BuiltinOptMult());
+        $this->set(Insn::OPT_DIV, new BuiltinOptDiv());
+        $this->set(Insn::OPT_MOD, new BuiltinOptMod());
+        $this->set(Insn::OPT_EQ, new BuiltinOptEq());
+        $this->set(Insn::OPT_NEQ, new BuiltinOptNeq());
+        $this->set(Insn::OPT_LT, new BuiltinOptLt());
+        $this->set(Insn::OPT_LE, new BuiltinOptLe());
+        $this->set(Insn::OPT_GT, new BuiltinOptGt());
+        $this->set(Insn::OPT_GE, new BuiltinOptGe());
+        $this->set(Insn::OPT_LTLT, new BuiltinOptLtlt());
+        $this->set(Insn::OPT_AND, new BuiltinOptAnd());
+        $this->set(Insn::OPT_OR, new BuiltinOptOr());
+        $this->set(Insn::OPT_AREF, new BuiltinOptAref());
+        $this->set(Insn::OPT_ASET, new BuiltinOptAset());
+        $this->set(Insn::OPT_ASET_WITH, new BuiltinOptAsetWith());
+        $this->set(Insn::OPT_AREF_WITH, new BuiltinOptArefWith());
+        $this->set(Insn::OPT_LENGTH, new BuiltinOptLength());
+        $this->set(Insn::OPT_SIZE, new BuiltinOptSize());
+        $this->set(Insn::OPT_EMPTY_P, new BuiltinOptEmptyP());
+        $this->set(Insn::OPT_SUCC, new BuiltinOptSucc());
+        $this->set(Insn::OPT_NOT, new BuiltinOptNot());
+        $this->set(Insn::OPT_REGEXPMATCH2, new BuiltinOptRegexpmatch2());
+        $this->set(Insn::INVOKEBUILTIN, new BuiltinInvokebuiltin());
+        $this->set(Insn::OPT_INVOKEBUILTIN_DELEGATE, new BuiltinOptInvokebuiltinDelegate());
+        $this->set(Insn::OPT_INVOKEBUILTIN_DELEGATE_LEAVE, new BuiltinOptInvokebuiltinDelegateLeave());
+        $this->set(Insn::GETLOCAL_WC_0, new BuiltinGetlocalWC0());
+        $this->set(Insn::GETLOCAL_WC_1, new BuiltinGetlocalWC1());
+        $this->set(Insn::SETLOCAL_WC_0, new BuiltinSetlocalWC0());
+        $this->set(Insn::SETLOCAL_WC_1, new BuiltinSetlocalWC1());
+        $this->set(Insn::PUTOBJECT_INT2FIX_0_, new BuiltinPutobjectINT2FIX0());
+        $this->set(Insn::PUTOBJECT_INT2FIX_1_, new BuiltinPutobjectINT2FIX1());
+        $this->set(Insn::TRACE_NOP, new BuiltinTraceNop());
+        $this->set(Insn::TRACE_GETLOCAL, new BuiltinTraceGetlocal());
+        $this->set(Insn::TRACE_SETLOCAL, new BuiltinTraceSetlocal());
+        $this->set(Insn::TRACE_GETBLOCKPARAM, new BuiltinTraceGetblockparam());
+        $this->set(Insn::TRACE_SETBLOCKPARAM, new BuiltinTraceSetblockparam());
+        $this->set(Insn::TRACE_GETBLOCKPARAMPROXY, new BuiltinTraceGetblockparamproxy());
+        $this->set(Insn::TRACE_GETSPECIAL, new BuiltinTraceGetspecial());
+        $this->set(Insn::TRACE_SETSPECIAL, new BuiltinTraceSetspecial());
+        $this->set(Insn::TRACE_GETINSTANCEVARIABLE, new BuiltinTraceGetinstancevariable());
+        $this->set(Insn::TRACE_SETINSTANCEVARIABLE, new BuiltinTraceSetinstancevariable());
+        $this->set(Insn::TRACE_GETCLASSVARIABLE, new BuiltinTraceGetclassvariable());
+        $this->set(Insn::TRACE_SETCLASSVARIABLE, new BuiltinTraceSetclassvariable());
+        $this->set(Insn::TRACE_OPT_GETCONSTANT_PATH, new BuiltinTraceOptGetconstantPath());
+        $this->set(Insn::TRACE_GETCONSTANT, new BuiltinTraceGetconstant());
+        $this->set(Insn::TRACE_SETCONSTANT, new BuiltinTraceSetconstant());
+        $this->set(Insn::TRACE_GETGLOBAL, new BuiltinTraceGetglobal());
+        $this->set(Insn::TRACE_SETGLOBAL, new BuiltinTraceSetglobal());
+        $this->set(Insn::TRACE_PUTNIL, new BuiltinTracePutnil());
+        $this->set(Insn::TRACE_PUTSELF, new BuiltinTracePutself());
+        $this->set(Insn::TRACE_PUTOBJECT, new BuiltinTracePutobject());
+        $this->set(Insn::TRACE_PUTSPECIALOBJECT, new BuiltinTracePutspecialobject());
+        $this->set(Insn::TRACE_PUTSTRING, new BuiltinTracePutstring());
+        $this->set(Insn::TRACE_CONCATSTRINGS, new BuiltinTraceConcatstrings());
+        $this->set(Insn::TRACE_ANYTOSTRING, new BuiltinTraceAnytostring());
+        $this->set(Insn::TRACE_TOREGEXP, new BuiltinTraceToregexp());
+        $this->set(Insn::TRACE_INTERN, new BuiltinTraceIntern());
+        $this->set(Insn::TRACE_NEWARRAY, new BuiltinTraceNewarray());
+        $this->set(Insn::TRACE_NEWARRAYKWSPLAT, new BuiltinTraceNewarraykwsplat());
+        $this->set(Insn::TRACE_DUPARRAY, new BuiltinTraceDuparray());
+        $this->set(Insn::TRACE_DUPHASH, new BuiltinTraceDuphash());
+        $this->set(Insn::TRACE_EXPANDARRAY, new BuiltinTraceExpandarray());
+        $this->set(Insn::TRACE_CONCATARRAY, new BuiltinTraceConcatarray());
+        $this->set(Insn::TRACE_SPLATARRAY, new BuiltinTraceSplatarray());
+        $this->set(Insn::TRACE_NEWHASH, new BuiltinTraceNewhash());
+        $this->set(Insn::TRACE_NEWRANGE, new BuiltinTraceNewrange());
+        $this->set(Insn::TRACE_POP, new BuiltinTracePop());
+        $this->set(Insn::TRACE_DUP, new BuiltinTraceDup());
+        $this->set(Insn::TRACE_DUPN, new BuiltinTraceDupn());
+        $this->set(Insn::TRACE_SWAP, new BuiltinTraceSwap());
+        $this->set(Insn::TRACE_OPT_REVERSE, new BuiltinTraceOptReverse());
+        $this->set(Insn::TRACE_TOPN, new BuiltinTraceTopn());
+        $this->set(Insn::TRACE_SETN, new BuiltinTraceSetn());
+        $this->set(Insn::TRACE_ADJUSTSTACK, new BuiltinTraceAdjuststack());
+        $this->set(Insn::TRACE_DEFINED, new BuiltinTraceDefined());
+        $this->set(Insn::TRACE_CHECKMATCH, new BuiltinTraceCheckmatch());
+        $this->set(Insn::TRACE_CHECKKEYWORD, new BuiltinTraceCheckkeyword());
+        $this->set(Insn::TRACE_CHECKTYPE, new BuiltinTraceChecktype());
+        $this->set(Insn::TRACE_DEFINECLASS, new BuiltinTraceDefineclass());
+        $this->set(Insn::TRACE_DEFINEMETHOD, new BuiltinTraceDefinemethod());
+        $this->set(Insn::TRACE_DEFINESMETHOD, new BuiltinTraceDefinesmethod());
+        $this->set(Insn::TRACE_SEND, new BuiltinTraceSend());
+        $this->set(Insn::TRACE_OPT_SEND_WITHOUT_BLOCK, new BuiltinTraceOptSendWithoutBlock());
+        $this->set(Insn::TRACE_OBJTOSTRING, new BuiltinTraceObjtostring());
+        $this->set(Insn::TRACE_OPT_STR_FREEZE, new BuiltinTraceOptStrFreeze());
+        $this->set(Insn::TRACE_OPT_NIL_P, new BuiltinTraceOptNilP());
+        $this->set(Insn::TRACE_OPT_STR_UMINUS, new BuiltinTraceOptStrUminus());
+        $this->set(Insn::TRACE_INVOKESUPER, new BuiltinTraceInvokesuper());
+        $this->set(Insn::TRACE_INVOKEBLOCK, new BuiltinTraceInvokeblock());
+        $this->set(Insn::TRACE_LEAVE, new BuiltinTraceLeave());
+        $this->set(Insn::TRACE_THROW, new BuiltinTraceThrow());
+        $this->set(Insn::TRACE_JUMP, new BuiltinTraceJump());
+        $this->set(Insn::TRACE_BRANCHIF, new BuiltinTraceBranchif());
+        $this->set(Insn::TRACE_BRANCHUNLESS, new BuiltinTraceBranchunless());
+        $this->set(Insn::TRACE_BRANCHNIL, new BuiltinTraceBranchnil());
+        $this->set(Insn::TRACE_ONCE, new BuiltinTraceOnce());
+        $this->set(Insn::TRACE_OPT_CASE_DISPATCH, new BuiltinTraceOptCaseDispatch());
+        $this->set(Insn::TRACE_OPT_PLUS, new BuiltinTraceOptPlus());
+        $this->set(Insn::TRACE_OPT_MINUS, new BuiltinTraceOptMinus());
+        $this->set(Insn::TRACE_OPT_MULT, new BuiltinTraceOptMult());
+        $this->set(Insn::TRACE_OPT_DIV, new BuiltinTraceOptDiv());
+        $this->set(Insn::TRACE_OPT_MOD, new BuiltinTraceOptMod());
+        $this->set(Insn::TRACE_OPT_EQ, new BuiltinTraceOptEq());
+        $this->set(Insn::TRACE_OPT_NEQ, new BuiltinTraceOptNeq());
+        $this->set(Insn::TRACE_OPT_LT, new BuiltinTraceOptLt());
+        $this->set(Insn::TRACE_OPT_LE, new BuiltinTraceOptLe());
+        $this->set(Insn::TRACE_OPT_GT, new BuiltinTraceOptGt());
+        $this->set(Insn::TRACE_OPT_GE, new BuiltinTraceOptGe());
+        $this->set(Insn::TRACE_OPT_LTLT, new BuiltinTraceOptLtlt());
+        $this->set(Insn::TRACE_OPT_AND, new BuiltinTraceOptAnd());
+        $this->set(Insn::TRACE_OPT_OR, new BuiltinTraceOptOr());
+        $this->set(Insn::TRACE_OPT_AREF, new BuiltinTraceOptAref());
+        $this->set(Insn::TRACE_OPT_ASET, new BuiltinTraceOptAset());
+        $this->set(Insn::TRACE_OPT_ASET_WITH, new BuiltinTraceOptAsetWith());
+        $this->set(Insn::TRACE_OPT_AREF_WITH, new BuiltinTraceOptArefWith());
+        $this->set(Insn::TRACE_OPT_LENGTH, new BuiltinTraceOptLength());
+        $this->set(Insn::TRACE_OPT_SIZE, new BuiltinTraceOptSize());
+        $this->set(Insn::TRACE_OPT_EMPTY_P, new BuiltinTraceOptEmptyP());
+        $this->set(Insn::TRACE_OPT_SUCC, new BuiltinTraceOptSucc());
+        $this->set(Insn::TRACE_OPT_NOT, new BuiltinTraceOptNot());
+        $this->set(Insn::TRACE_OPT_REGEXPMATCH2, new BuiltinTraceOptRegexpmatch2());
+        $this->set(Insn::TRACE_INVOKEBUILTIN, new BuiltinTraceInvokebuiltin());
+        $this->set(Insn::TRACE_OPT_INVOKEBUILTIN_DELEGATE, new BuiltinTraceOptInvokebuiltinDelegate());
+        $this->set(Insn::TRACE_OPT_INVOKEBUILTIN_DELEGATE_LEAVE, new BuiltinTraceOptInvokebuiltinDelegateLeave());
+        $this->set(Insn::TRACE_GETLOCAL_WC_0, new BuiltinTraceGetlocalWC0());
+        $this->set(Insn::TRACE_GETLOCAL_WC_1, new BuiltinTraceGetlocalWC1());
+        $this->set(Insn::TRACE_SETLOCAL_WC_0, new BuiltinTraceSetlocalWC0());
+        $this->set(Insn::TRACE_SETLOCAL_WC_1, new BuiltinTraceSetlocalWC1());
+        $this->set(Insn::TRACE_PUTOBJECT_INT2FIX_0_, new BuiltinTracePutobjectINT2FIX0());
+        $this->set(Insn::TRACE_PUTOBJECT_INT2FIX_1_, new BuiltinTracePutobjectINT2FIX1());
+    }
+}
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php
index 87a2bcd7..62ca9206 100644
--- a/src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php
@@ -20,6 +20,7 @@
 
 use RubyVM\VM\Core\Runtime\Essential\KernelInterface;
 use RubyVM\VM\Core\Runtime\Essential\RubyVMInterface;
+use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorEntries;
 use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\HeapSpace\DefaultInstanceHeapSpace;
 use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence\InstructionSequenceProcessor;
 use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Loader\ArraySymbolLoader;
@@ -74,7 +75,7 @@ class Kernel implements KernelInterface
 
     public readonly int $endian;
 
-    public readonly int $short;
+    public readonly int $wordSize;
 
     public readonly Offsets $instructionSequenceList;
 
@@ -130,7 +131,7 @@ public function setup(): self
         $this->globalObjectListOffset = $this->stream()->readAsUnsignedLong();
         $this->endian = $this->stream()->readAsShort();
         $this->wordSize = $this->stream()->readAsShort();
-        $this->rubyPlatform = $this->stream()->readAsString();
+        $this->rubyPlatform = 'unknown-unknown';
 
         $this->vm->option()->logger->info(
             sprintf('Loaded an instruction sequence header (%d bytes)', $this->stream()->pos() - $pos),
@@ -386,4 +387,10 @@ public function instructionSequenceList(): Offsets
     {
         return $this->instructionSequenceList;
     }
+
+    public function operationProcessorEntries(): OperationProcessorEntries
+    {
+        static $entries;
+        return $entries ??= new \RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence\OperationProcessorEntries();
+    }
 }
diff --git a/src/VM/Core/Runtime/Option.php b/src/VM/Core/Runtime/Option.php
index 1035c8cf..bcaee632 100644
--- a/src/VM/Core/Runtime/Option.php
+++ b/src/VM/Core/Runtime/Option.php
@@ -8,7 +8,6 @@
 use RubyVM\VM\Core\Runtime\Essential\MainInterface;
 use RubyVM\VM\Core\Runtime\Executor\Debugger\DebuggerInterface;
 use RubyVM\VM\Core\Runtime\Executor\Debugger\DefaultExecutorDebugger;
-use RubyVM\VM\Core\Runtime\Executor\Operation\DefaultOperationProcessorEntries;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorEntries;
 use RubyVM\VM\Stream\BinaryStreamReaderInterface;
 use RubyVM\VM\Stream\StreamHandler;
@@ -43,7 +42,6 @@ public function __construct(
         private ?StreamHandlerInterface $stdIn = null,
         private ?StreamHandlerInterface $stdErr = null,
         private ?DebuggerInterface $debugger = null,
-        private ?OperationProcessorEntries $operationProcessorEntries = null,
     ) {}
 
     public function entryPointIndex(): int
@@ -71,11 +69,6 @@ public function stdErr(): StreamHandlerInterface
         return $this->stdErr ??= new StreamHandler(STDERR);
     }
 
-    public function operationProcessorEntries(): OperationProcessorEntries
-    {
-        return $this->operationProcessorEntries ??= new DefaultOperationProcessorEntries();
-    }
-
     public function debugger(): DebuggerInterface
     {
         return $this->debugger ??= new DefaultExecutorDebugger();
diff --git a/src/VM/Core/Runtime/OptionInterface.php b/src/VM/Core/Runtime/OptionInterface.php
index 9dbbc7f6..539fcb6a 100644
--- a/src/VM/Core/Runtime/OptionInterface.php
+++ b/src/VM/Core/Runtime/OptionInterface.php
@@ -21,7 +21,5 @@ public function stdIn(): StreamHandlerInterface;
 
     public function stdErr(): StreamHandlerInterface;
 
-    public function operationProcessorEntries(): OperationProcessorEntries;
-
     public function debugger(): DebuggerInterface;
 }
diff --git a/tests/Internal/DebugFormatTest.php b/tests/Internal/DebugFormatTest.php
index b2687d53..280404c8 100644
--- a/tests/Internal/DebugFormatTest.php
+++ b/tests/Internal/DebugFormatTest.php
@@ -2,14 +2,15 @@
 
 declare(strict_types=1);
 
-namespace Tests\RubyVM\Version\RubyVM\Internal;
+namespace Tests\RubyVM\Internal;
 
 use RubyVM\VM\Core\Criterion\Entry\AbstractEntries;
 use RubyVM\VM\Core\Runtime\BasicObject\Kernel\Object_\Comparable\Integer_;
 use RubyVM\VM\Core\Runtime\Executor\Debugger\DebugFormat;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Insn;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operand;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operation;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_2\InstructionSequence\Insn as Ruby3_2_Insn;
+use RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence\Insn as Ruby3_3_Insn;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
@@ -32,7 +33,10 @@ public function __toString(): string
             }
         };
 
-        $class[] = new Operation(Insn::SEND);
+        $class[] = new Operation(match ("{$this->major}.{$this->minor}") {
+            "3.3" => Ruby3_3_Insn::SEND,
+            default => Ruby3_2_Insn::SEND,
+        });
         $class[] = new Operand(Integer_::createBy(0));
         $class[] = new Operand(Integer_::createBy(65535));
         $class[] = new Operand(Integer_::createBy(-128));
diff --git a/tests/Version/RubyVM/YARB/YARBStructureTest.php b/tests/Version/RubyVM/YARB/YARBStructureTest.php
index 3e93b791..b63a2d9f 100644
--- a/tests/Version/RubyVM/YARB/YARBStructureTest.php
+++ b/tests/Version/RubyVM/YARB/YARBStructureTest.php
@@ -22,7 +22,11 @@ public function testHeader(): void
         );
         $rubyVMManager->rubyVM->runtime()->setup();
         $this->assertSame("{$this->major}.{$this->minor}", $rubyVMManager->rubyVM->runtime()->rubyVersion());
-        if ($this->isCI()) {
+
+        // TODO: Fix to be flexible when using any ruby version
+        if ("{$this->major}.{$this->minor}" === "3.3") {
+            $this->assertSame('unknown-unknown', $rubyVMManager->rubyVM->runtime()->rubyPlatform());
+        } elseif ($this->isCI()) {
             $this->assertSame('x86_64-linux', $rubyVMManager->rubyVM->runtime()->rubyPlatform());
         } else {
             $this->assertSame('arm64-darwin22', $rubyVMManager->rubyVM->runtime()->rubyPlatform());

From df0b18198d31f4b681da040c7fde850b289cb261 Mon Sep 17 00:00:00 2001
From: m3m0r7 <memory.style.serv@gmail.com>
Date: Wed, 27 Dec 2023 00:56:32 +0900
Subject: [PATCH 09/11] Linting files

---
 composer.lock                                 | 414 +++++++++---------
 rector.php                                    |   1 -
 .../Core/Criterion/Entry/AbstractEntries.php  |   4 +-
 .../Core/Runtime/BasicObject/BasicObject.php  |   2 +-
 .../Kernel/Object_/Comparable/Integer_.php    |  18 +-
 .../Kernel/Object_/Comparable/String_.php     |   4 +-
 .../Kernel/Object_/Enumerable/Array_.php      |   2 +-
 .../Kernel/Object_/Enumerable/Range.php       |   2 +-
 .../BasicObject/Kernel/Object_/Object_.php    |   2 +-
 .../BasicObject/Kernel/Object_/Proc.php       |   2 +-
 .../BasicObject/Kernel/Object_/Regexp.php     |   2 +-
 .../Runtime/Executor/Accessor/Translator.php  |   2 +-
 .../Core/Runtime/Executor/CallBlockHelper.php |   6 +-
 .../Debugger/DefaultExecutorDebugger.php      |   2 +-
 .../Executor/Debugger/StepByStepDebugger.php  |   2 +-
 .../Runtime/Executor/EnvironmentTable.php     |   2 +-
 .../Core/Runtime/Executor/ExecutedResult.php  |   2 +-
 src/VM/Core/Runtime/Executor/Executor.php     |  13 +-
 .../Insn/Processor/BuiltinAdjuststack.php     |   2 +-
 .../Insn/Processor/BuiltinAnytostring.php     |   2 +-
 .../Insn/Processor/BuiltinBranchnil.php       |   2 +-
 .../Insn/Processor/BuiltinCheckkeyword.php    |   2 +-
 .../Insn/Processor/BuiltinCheckmatch.php      |   2 +-
 .../Insn/Processor/BuiltinChecktype.php       |   2 +-
 .../Insn/Processor/BuiltinConcatstrings.php   |   2 +-
 .../Insn/Processor/BuiltinDefinesmethod.php   |   2 +-
 .../Insn/Processor/BuiltinDuphash.php         |   2 +-
 .../Executor/Insn/Processor/BuiltinDupn.php   |   2 +-
 .../Insn/Processor/BuiltinExpandarray.php     |   2 +-
 .../Processor/BuiltinGetclassvariable.php     |   2 +-
 .../Insn/Processor/BuiltinGetconstant.php     |   2 +-
 .../Insn/Processor/BuiltinGetspecial.php      |   2 +-
 .../Executor/Insn/Processor/BuiltinIntern.php |   2 +-
 .../Insn/Processor/BuiltinInvokebuiltin.php   |   2 +-
 .../Insn/Processor/BuiltinInvokesuper.php     |   2 +-
 .../Insn/Processor/BuiltinNewarraykwsplat.php |   2 +-
 .../Insn/Processor/BuiltinObjtostring.php     |   2 +-
 .../Executor/Insn/Processor/BuiltinOnce.php   |   2 +-
 .../Insn/Processor/BuiltinOptArefWith.php     |   2 +-
 .../Insn/Processor/BuiltinOptAset.php         |   2 +-
 .../Insn/Processor/BuiltinOptAsetWith.php     |   2 +-
 .../BuiltinOptInvokebuiltinDelegate.php       |   2 +-
 .../BuiltinOptInvokebuiltinDelegateLeave.php  |   2 +-
 .../Insn/Processor/BuiltinOptLength.php       |   2 +-
 .../Executor/Insn/Processor/BuiltinOptNeq.php |   2 +-
 .../Insn/Processor/BuiltinOptNewarrayMax.php  |   2 +-
 .../Insn/Processor/BuiltinOptNewarrayMin.php  |   2 +-
 .../Executor/Insn/Processor/BuiltinOptNot.php |   2 +-
 .../Insn/Processor/BuiltinOptReverse.php      |   2 +-
 .../Insn/Processor/BuiltinOptSize.php         |   2 +-
 .../Insn/Processor/BuiltinOptStrFreeze.php    |   2 +-
 .../Insn/Processor/BuiltinOptStrUminus.php    |   2 +-
 .../Insn/Processor/BuiltinOptSucc.php         |   2 +-
 .../Insn/Processor/BuiltinSetblockparam.php   |   2 +-
 .../Processor/BuiltinSetclassvariable.php     |   2 +-
 .../Insn/Processor/BuiltinSetconstant.php     |   2 +-
 .../Executor/Insn/Processor/BuiltinSetn.php   |   2 +-
 .../Insn/Processor/BuiltinSetspecial.php      |   2 +-
 .../Executor/Insn/Processor/BuiltinSwap.php   |   2 +-
 .../Executor/Insn/Processor/BuiltinThrow.php  |   2 +-
 .../Insn/Processor/BuiltinToregexp.php        |   2 +-
 .../Processor/BuiltinTraceAdjuststack.php     |   2 +-
 .../Processor/BuiltinTraceAnytostring.php     |   2 +-
 .../Insn/Processor/BuiltinTraceBranchif.php   |   2 +-
 .../Insn/Processor/BuiltinTraceBranchnil.php  |   2 +-
 .../Processor/BuiltinTraceBranchunless.php    |   2 +-
 .../Processor/BuiltinTraceCheckkeyword.php    |   2 +-
 .../Insn/Processor/BuiltinTraceCheckmatch.php |   2 +-
 .../Insn/Processor/BuiltinTraceChecktype.php  |   2 +-
 .../Processor/BuiltinTraceConcatarray.php     |   2 +-
 .../Processor/BuiltinTraceConcatstrings.php   |   2 +-
 .../Processor/BuiltinTraceDefineclass.php     |   2 +-
 .../Insn/Processor/BuiltinTraceDefined.php    |   2 +-
 .../Processor/BuiltinTraceDefinemethod.php    |   2 +-
 .../Processor/BuiltinTraceDefinesmethod.php   |   2 +-
 .../Insn/Processor/BuiltinTraceDup.php        |   2 +-
 .../Insn/Processor/BuiltinTraceDuparray.php   |   2 +-
 .../Insn/Processor/BuiltinTraceDuphash.php    |   2 +-
 .../Insn/Processor/BuiltinTraceDupn.php       |   2 +-
 .../Processor/BuiltinTraceExpandarray.php     |   2 +-
 .../Processor/BuiltinTraceGetblockparam.php   |   2 +-
 .../BuiltinTraceGetblockparamproxy.php        |   2 +-
 .../BuiltinTraceGetclassvariable.php          |   2 +-
 .../Processor/BuiltinTraceGetconstant.php     |   2 +-
 .../Insn/Processor/BuiltinTraceGetglobal.php  |   2 +-
 .../BuiltinTraceGetinstancevariable.php       |   2 +-
 .../Insn/Processor/BuiltinTraceGetlocal.php   |   2 +-
 .../Processor/BuiltinTraceGetlocalWC0.php     |   2 +-
 .../Processor/BuiltinTraceGetlocalWC1.php     |   2 +-
 .../Insn/Processor/BuiltinTraceGetspecial.php |   2 +-
 .../Insn/Processor/BuiltinTraceIntern.php     |   2 +-
 .../Processor/BuiltinTraceInvokeblock.php     |   2 +-
 .../Processor/BuiltinTraceInvokebuiltin.php   |   2 +-
 .../Processor/BuiltinTraceInvokesuper.php     |   2 +-
 .../Insn/Processor/BuiltinTraceJump.php       |   2 +-
 .../Insn/Processor/BuiltinTraceLeave.php      |   2 +-
 .../Insn/Processor/BuiltinTraceNewarray.php   |   2 +-
 .../Processor/BuiltinTraceNewarraykwsplat.php |   2 +-
 .../Insn/Processor/BuiltinTraceNewhash.php    |   2 +-
 .../Insn/Processor/BuiltinTraceNewrange.php   |   2 +-
 .../Insn/Processor/BuiltinTraceNop.php        |   2 +-
 .../Processor/BuiltinTraceObjtostring.php     |   2 +-
 .../Insn/Processor/BuiltinTraceOnce.php       |   2 +-
 .../Insn/Processor/BuiltinTraceOptAnd.php     |   2 +-
 .../Insn/Processor/BuiltinTraceOptAref.php    |   2 +-
 .../Processor/BuiltinTraceOptArefWith.php     |   2 +-
 .../Insn/Processor/BuiltinTraceOptAset.php    |   2 +-
 .../Processor/BuiltinTraceOptAsetWith.php     |   2 +-
 .../Processor/BuiltinTraceOptCaseDispatch.php |   2 +-
 .../Insn/Processor/BuiltinTraceOptDiv.php     |   2 +-
 .../Insn/Processor/BuiltinTraceOptEmptyP.php  |   2 +-
 .../Insn/Processor/BuiltinTraceOptEq.php      |   2 +-
 .../Insn/Processor/BuiltinTraceOptGe.php      |   2 +-
 .../BuiltinTraceOptGetconstantPath.php        |   2 +-
 .../Insn/Processor/BuiltinTraceOptGt.php      |   2 +-
 .../BuiltinTraceOptInvokebuiltinDelegate.php  |   2 +-
 ...ltinTraceOptInvokebuiltinDelegateLeave.php |   2 +-
 .../Insn/Processor/BuiltinTraceOptLe.php      |   2 +-
 .../Insn/Processor/BuiltinTraceOptLength.php  |   2 +-
 .../Insn/Processor/BuiltinTraceOptLt.php      |   2 +-
 .../Insn/Processor/BuiltinTraceOptLtlt.php    |   2 +-
 .../Insn/Processor/BuiltinTraceOptMinus.php   |   2 +-
 .../Insn/Processor/BuiltinTraceOptMod.php     |   2 +-
 .../Insn/Processor/BuiltinTraceOptMult.php    |   2 +-
 .../Insn/Processor/BuiltinTraceOptNeq.php     |   2 +-
 .../Processor/BuiltinTraceOptNewarrayMax.php  |   2 +-
 .../Processor/BuiltinTraceOptNewarrayMin.php  |   2 +-
 .../Insn/Processor/BuiltinTraceOptNilP.php    |   2 +-
 .../Insn/Processor/BuiltinTraceOptNot.php     |   2 +-
 .../Insn/Processor/BuiltinTraceOptOr.php      |   2 +-
 .../Insn/Processor/BuiltinTraceOptPlus.php    |   2 +-
 .../Processor/BuiltinTraceOptRegexpmatch2.php |   2 +-
 .../Insn/Processor/BuiltinTraceOptReverse.php |   2 +-
 .../BuiltinTraceOptSendWithoutBlock.php       |   2 +-
 .../Insn/Processor/BuiltinTraceOptSize.php    |   2 +-
 .../Processor/BuiltinTraceOptStrFreeze.php    |   2 +-
 .../Processor/BuiltinTraceOptStrUminus.php    |   2 +-
 .../Insn/Processor/BuiltinTraceOptSucc.php    |   2 +-
 .../Insn/Processor/BuiltinTracePop.php        |   2 +-
 .../Insn/Processor/BuiltinTracePutnil.php     |   2 +-
 .../Insn/Processor/BuiltinTracePutobject.php  |   2 +-
 .../BuiltinTracePutobjectINT2FIX0.php         |   2 +-
 .../BuiltinTracePutobjectINT2FIX1.php         |   2 +-
 .../Insn/Processor/BuiltinTracePutself.php    |   2 +-
 .../BuiltinTracePutspecialobject.php          |   2 +-
 .../Insn/Processor/BuiltinTracePutstring.php  |   2 +-
 .../Insn/Processor/BuiltinTraceSend.php       |   2 +-
 .../Processor/BuiltinTraceSetblockparam.php   |   2 +-
 .../BuiltinTraceSetclassvariable.php          |   2 +-
 .../Processor/BuiltinTraceSetconstant.php     |   2 +-
 .../Insn/Processor/BuiltinTraceSetglobal.php  |   2 +-
 .../BuiltinTraceSetinstancevariable.php       |   2 +-
 .../Insn/Processor/BuiltinTraceSetlocal.php   |   2 +-
 .../Processor/BuiltinTraceSetlocalWC0.php     |   2 +-
 .../Processor/BuiltinTraceSetlocalWC1.php     |   2 +-
 .../Insn/Processor/BuiltinTraceSetn.php       |   2 +-
 .../Insn/Processor/BuiltinTraceSetspecial.php |   2 +-
 .../Insn/Processor/BuiltinTraceSplatarray.php |   2 +-
 .../Insn/Processor/BuiltinTraceSwap.php       |   2 +-
 .../Insn/Processor/BuiltinTraceThrow.php      |   2 +-
 .../Insn/Processor/BuiltinTraceTopn.php       |   2 +-
 .../Insn/Processor/BuiltinTraceToregexp.php   |   2 +-
 .../Runtime/Executor/Operation/Operand.php    |   2 +-
 .../Executor/Operation/OperandHelper.php      |   6 +-
 .../Executor/Operation/OperationEntries.php   |   2 +-
 .../Processor/OperationProcessorEntries.php   |   2 +-
 src/VM/Core/Runtime/Kernel/Ruby3_2/Kernel.php |   4 +-
 .../InstructionSequenceProcessor.php          |  82 ++--
 .../OperationProcessorEntries.php             |   4 -
 src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php |   4 +-
 src/VM/Core/Runtime/Option.php                |   1 -
 src/VM/Core/Runtime/OptionInterface.php       |   1 -
 .../Provider/ProvideExtendedMethodCall.php    |   2 +-
 src/VM/Core/Runtime/RubyVM.php                |   6 +-
 src/VM/Core/Runtime/UserlandClassEntries.php  |   2 +-
 src/VM/Core/YARV/Criterion/Offset/Offset.php  |   2 +-
 .../Criterion/Structure/AbstractStructure.php |   2 +-
 .../Structure/StructureInterface.php          |   2 +-
 .../YARV/Essential/Symbol/RangeSymbol.php     |   4 +-
 .../YARV/Essential/Symbol/RegexpSymbol.php    |   4 +-
 src/VM/Stream/BinaryStreamReader.php          |   4 +-
 src/VM/Stream/BinaryStreamReaderInterface.php |   4 +-
 tests/Helper/TestApplication.php              |   2 +
 tests/Internal/DebugFormatTest.php            |   2 +-
 .../Kernel/Object_/Comparable/IntegerTest.php |   1 -
 .../Kernel/Object_/Comparable/StringTest.php  |   1 -
 .../Kernel/Object_/Enumerable/ArrayTest.php   |   1 -
 .../Kernel/Object_/Enumerable/RangeTest.php   |   1 -
 .../Call/Logic/Complex/FibonacciTest.php      |   1 -
 .../Call/Logic/Complex/FizzBuzzTest.php       |   1 -
 .../Call/Logic/Complex/QuicksortTest.php      |   1 -
 tests/Version/RubyVM/Call/Method/ExitTest.php |   1 -
 .../RubyVM/Call/Method/InspectionTest.php     |   1 -
 .../Version/RubyVM/Call/Method/MethodTest.php |   1 -
 tests/Version/RubyVM/Call/Method/NilTest.php  |   1 -
 tests/Version/RubyVM/Call/Method/PTest.php    |   1 -
 tests/Version/RubyVM/Call/Method/ProcTest.php |   1 -
 .../Version/RubyVM/Call/Method/ToIntTest.php  |   1 -
 .../RubyVM/Call/Method/ToStringTest.php       |   1 -
 .../RubyVM/Call/PHP/CallRubyMethodsTest.php   |   1 -
 .../RubyVM/GenericSyntax/ArithmeticTest.php   |   1 -
 .../RubyVM/GenericSyntax/BlockTest.php        |   1 -
 .../RubyVM/GenericSyntax/BooleanTest.php      |   1 -
 .../RubyVM/GenericSyntax/CaseWhenTest.php     |   1 -
 .../GenericSyntax/Class/DefineClassTest.php   |   1 -
 .../Class/DefineMethodInClassTest.php         |   1 -
 .../Class/DefineStaticMethodTest.php          |   1 -
 .../GenericSyntax/Class/ExtendedClassTest.php |   1 -
 .../Class/InstanceVariableTest.php            |   1 -
 .../RubyVM/GenericSyntax/ComparableTest.php   |   1 -
 .../RubyVM/GenericSyntax/ConcatTest.php       |   1 -
 .../RubyVM/GenericSyntax/DefinedTest.php      |   1 -
 .../GenericSyntax/GlobalVariableTest.php      |   1 -
 .../Version/RubyVM/GenericSyntax/HashTest.php |   1 -
 .../GenericSyntax/KeywordArgumentsTest.php    |   1 -
 .../GenericSyntax/LocalVariableTest.php       |   1 -
 .../RubyVM/GenericSyntax/Method/BlockTest.php |   1 -
 .../GenericSyntax/Method/DefineMethodTest.php |   1 -
 .../GenericSyntax/NegativeValueTest.php       |   1 -
 .../RubyVM/GenericSyntax/RaiseTest.php        |   1 -
 .../RubyVM/GenericSyntax/RegexpTest.php       |   1 -
 .../RubyVM/GenericSyntax/RescueTest.php       |   1 -
 .../RubyVM/GenericSyntax/SymbolTest.php       |   1 -
 .../RubyVM/GenericSyntax/VariadicTest.php     |   1 -
 .../Version/RubyVM/YARB/YARBStructureTest.php |   2 +-
 225 files changed, 467 insertions(+), 489 deletions(-)

diff --git a/composer.lock b/composer.lock
index e447f482..e1c8f566 100644
--- a/composer.lock
+++ b/composer.lock
@@ -8,16 +8,16 @@
     "packages": [
         {
             "name": "monolog/monolog",
-            "version": "3.4.0",
+            "version": "3.5.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/Seldaek/monolog.git",
-                "reference": "e2392369686d420ca32df3803de28b5d6f76867d"
+                "reference": "c915e2634718dbc8a4a15c61b0e62e7a44e14448"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/Seldaek/monolog/zipball/e2392369686d420ca32df3803de28b5d6f76867d",
-                "reference": "e2392369686d420ca32df3803de28b5d6f76867d",
+                "url": "https://api.github.com/repos/Seldaek/monolog/zipball/c915e2634718dbc8a4a15c61b0e62e7a44e14448",
+                "reference": "c915e2634718dbc8a4a15c61b0e62e7a44e14448",
                 "shasum": ""
             },
             "require": {
@@ -93,7 +93,7 @@
             ],
             "support": {
                 "issues": "https://github.com/Seldaek/monolog/issues",
-                "source": "https://github.com/Seldaek/monolog/tree/3.4.0"
+                "source": "https://github.com/Seldaek/monolog/tree/3.5.0"
             },
             "funding": [
                 {
@@ -105,7 +105,7 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2023-06-21T08:46:11+00:00"
+            "time": "2023-10-27T15:32:31+00:00"
         },
         {
             "name": "psr/container",
@@ -212,16 +212,16 @@
         },
         {
             "name": "symfony/console",
-            "version": "v6.3.4",
+            "version": "v6.4.1",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/console.git",
-                "reference": "eca495f2ee845130855ddf1cf18460c38966c8b6"
+                "reference": "a550a7c99daeedef3f9d23fb82e3531525ff11fd"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/console/zipball/eca495f2ee845130855ddf1cf18460c38966c8b6",
-                "reference": "eca495f2ee845130855ddf1cf18460c38966c8b6",
+                "url": "https://api.github.com/repos/symfony/console/zipball/a550a7c99daeedef3f9d23fb82e3531525ff11fd",
+                "reference": "a550a7c99daeedef3f9d23fb82e3531525ff11fd",
                 "shasum": ""
             },
             "require": {
@@ -229,7 +229,7 @@
                 "symfony/deprecation-contracts": "^2.5|^3",
                 "symfony/polyfill-mbstring": "~1.0",
                 "symfony/service-contracts": "^2.5|^3",
-                "symfony/string": "^5.4|^6.0"
+                "symfony/string": "^5.4|^6.0|^7.0"
             },
             "conflict": {
                 "symfony/dependency-injection": "<5.4",
@@ -243,12 +243,16 @@
             },
             "require-dev": {
                 "psr/log": "^1|^2|^3",
-                "symfony/config": "^5.4|^6.0",
-                "symfony/dependency-injection": "^5.4|^6.0",
-                "symfony/event-dispatcher": "^5.4|^6.0",
-                "symfony/lock": "^5.4|^6.0",
-                "symfony/process": "^5.4|^6.0",
-                "symfony/var-dumper": "^5.4|^6.0"
+                "symfony/config": "^5.4|^6.0|^7.0",
+                "symfony/dependency-injection": "^5.4|^6.0|^7.0",
+                "symfony/event-dispatcher": "^5.4|^6.0|^7.0",
+                "symfony/http-foundation": "^6.4|^7.0",
+                "symfony/http-kernel": "^6.4|^7.0",
+                "symfony/lock": "^5.4|^6.0|^7.0",
+                "symfony/messenger": "^5.4|^6.0|^7.0",
+                "symfony/process": "^5.4|^6.0|^7.0",
+                "symfony/stopwatch": "^5.4|^6.0|^7.0",
+                "symfony/var-dumper": "^5.4|^6.0|^7.0"
             },
             "type": "library",
             "autoload": {
@@ -282,7 +286,7 @@
                 "terminal"
             ],
             "support": {
-                "source": "https://github.com/symfony/console/tree/v6.3.4"
+                "source": "https://github.com/symfony/console/tree/v6.4.1"
             },
             "funding": [
                 {
@@ -298,11 +302,11 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2023-08-16T10:10:12+00:00"
+            "time": "2023-11-30T10:54:28+00:00"
         },
         {
             "name": "symfony/deprecation-contracts",
-            "version": "v3.3.0",
+            "version": "v3.4.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/deprecation-contracts.git",
@@ -349,7 +353,7 @@
             "description": "A generic function and convention to trigger deprecation notices",
             "homepage": "https://symfony.com",
             "support": {
-                "source": "https://github.com/symfony/deprecation-contracts/tree/v3.3.0"
+                "source": "https://github.com/symfony/deprecation-contracts/tree/v3.4.0"
             },
             "funding": [
                 {
@@ -699,16 +703,16 @@
         },
         {
             "name": "symfony/service-contracts",
-            "version": "v3.3.0",
+            "version": "v3.4.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/service-contracts.git",
-                "reference": "40da9cc13ec349d9e4966ce18b5fbcd724ab10a4"
+                "reference": "b3313c2dbffaf71c8de2934e2ea56ed2291a3838"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/service-contracts/zipball/40da9cc13ec349d9e4966ce18b5fbcd724ab10a4",
-                "reference": "40da9cc13ec349d9e4966ce18b5fbcd724ab10a4",
+                "url": "https://api.github.com/repos/symfony/service-contracts/zipball/b3313c2dbffaf71c8de2934e2ea56ed2291a3838",
+                "reference": "b3313c2dbffaf71c8de2934e2ea56ed2291a3838",
                 "shasum": ""
             },
             "require": {
@@ -761,7 +765,7 @@
                 "standards"
             ],
             "support": {
-                "source": "https://github.com/symfony/service-contracts/tree/v3.3.0"
+                "source": "https://github.com/symfony/service-contracts/tree/v3.4.0"
             },
             "funding": [
                 {
@@ -777,24 +781,24 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2023-05-23T14:45:45+00:00"
+            "time": "2023-07-30T20:28:31+00:00"
         },
         {
             "name": "symfony/string",
-            "version": "v6.3.2",
+            "version": "v7.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/string.git",
-                "reference": "53d1a83225002635bca3482fcbf963001313fb68"
+                "reference": "92bd2bfbba476d4a1838e5e12168bef2fd1e6620"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/string/zipball/53d1a83225002635bca3482fcbf963001313fb68",
-                "reference": "53d1a83225002635bca3482fcbf963001313fb68",
+                "url": "https://api.github.com/repos/symfony/string/zipball/92bd2bfbba476d4a1838e5e12168bef2fd1e6620",
+                "reference": "92bd2bfbba476d4a1838e5e12168bef2fd1e6620",
                 "shasum": ""
             },
             "require": {
-                "php": ">=8.1",
+                "php": ">=8.2",
                 "symfony/polyfill-ctype": "~1.8",
                 "symfony/polyfill-intl-grapheme": "~1.0",
                 "symfony/polyfill-intl-normalizer": "~1.0",
@@ -804,11 +808,11 @@
                 "symfony/translation-contracts": "<2.5"
             },
             "require-dev": {
-                "symfony/error-handler": "^5.4|^6.0",
-                "symfony/http-client": "^5.4|^6.0",
-                "symfony/intl": "^6.2",
+                "symfony/error-handler": "^6.4|^7.0",
+                "symfony/http-client": "^6.4|^7.0",
+                "symfony/intl": "^6.4|^7.0",
                 "symfony/translation-contracts": "^2.5|^3.0",
-                "symfony/var-exporter": "^5.4|^6.0"
+                "symfony/var-exporter": "^6.4|^7.0"
             },
             "type": "library",
             "autoload": {
@@ -847,7 +851,7 @@
                 "utf8"
             ],
             "support": {
-                "source": "https://github.com/symfony/string/tree/v6.3.2"
+                "source": "https://github.com/symfony/string/tree/v7.0.0"
             },
             "funding": [
                 {
@@ -863,22 +867,22 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2023-07-05T08:41:27+00:00"
+            "time": "2023-11-29T08:40:23+00:00"
         }
     ],
     "packages-dev": [
         {
             "name": "composer/pcre",
-            "version": "3.1.0",
+            "version": "3.1.1",
             "source": {
                 "type": "git",
                 "url": "https://github.com/composer/pcre.git",
-                "reference": "4bff79ddd77851fe3cdd11616ed3f92841ba5bd2"
+                "reference": "00104306927c7a0919b4ced2aaa6782c1e61a3c9"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/composer/pcre/zipball/4bff79ddd77851fe3cdd11616ed3f92841ba5bd2",
-                "reference": "4bff79ddd77851fe3cdd11616ed3f92841ba5bd2",
+                "url": "https://api.github.com/repos/composer/pcre/zipball/00104306927c7a0919b4ced2aaa6782c1e61a3c9",
+                "reference": "00104306927c7a0919b4ced2aaa6782c1e61a3c9",
                 "shasum": ""
             },
             "require": {
@@ -920,7 +924,7 @@
             ],
             "support": {
                 "issues": "https://github.com/composer/pcre/issues",
-                "source": "https://github.com/composer/pcre/tree/3.1.0"
+                "source": "https://github.com/composer/pcre/tree/3.1.1"
             },
             "funding": [
                 {
@@ -936,7 +940,7 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2022-11-17T09:50:14+00:00"
+            "time": "2023-10-11T07:11:09+00:00"
         },
         {
             "name": "composer/semver",
@@ -1087,52 +1091,47 @@
         },
         {
             "name": "friendsofphp/php-cs-fixer",
-            "version": "v3.31.0",
+            "version": "v3.42.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/PHP-CS-Fixer/PHP-CS-Fixer.git",
-                "reference": "983a24f6fe16bdcfd5af02b14a7683e3fb1b882e"
+                "reference": "632ef1be3447a9b890bef06147475facee535d0f"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/PHP-CS-Fixer/PHP-CS-Fixer/zipball/983a24f6fe16bdcfd5af02b14a7683e3fb1b882e",
-                "reference": "983a24f6fe16bdcfd5af02b14a7683e3fb1b882e",
+                "url": "https://api.github.com/repos/PHP-CS-Fixer/PHP-CS-Fixer/zipball/632ef1be3447a9b890bef06147475facee535d0f",
+                "reference": "632ef1be3447a9b890bef06147475facee535d0f",
                 "shasum": ""
             },
             "require": {
-                "composer/semver": "^3.3",
+                "composer/semver": "^3.4",
                 "composer/xdebug-handler": "^3.0.3",
                 "ext-json": "*",
                 "ext-tokenizer": "*",
                 "php": "^7.4 || ^8.0",
                 "sebastian/diff": "^4.0 || ^5.0",
-                "symfony/console": "^5.4 || ^6.0",
-                "symfony/event-dispatcher": "^5.4 || ^6.0",
-                "symfony/filesystem": "^5.4 || ^6.0",
-                "symfony/finder": "^5.4 || ^6.0",
-                "symfony/options-resolver": "^5.4 || ^6.0",
-                "symfony/polyfill-mbstring": "^1.27",
-                "symfony/polyfill-php80": "^1.27",
-                "symfony/polyfill-php81": "^1.27",
-                "symfony/process": "^5.4 || ^6.0",
-                "symfony/stopwatch": "^5.4 || ^6.0"
+                "symfony/console": "^5.4 || ^6.0 || ^7.0",
+                "symfony/event-dispatcher": "^5.4 || ^6.0 || ^7.0",
+                "symfony/filesystem": "^5.4 || ^6.0 || ^7.0",
+                "symfony/finder": "^5.4 || ^6.0 || ^7.0",
+                "symfony/options-resolver": "^5.4 || ^6.0 || ^7.0",
+                "symfony/polyfill-mbstring": "^1.28",
+                "symfony/polyfill-php80": "^1.28",
+                "symfony/polyfill-php81": "^1.28",
+                "symfony/process": "^5.4 || ^6.0 || ^7.0",
+                "symfony/stopwatch": "^5.4 || ^6.0 || ^7.0"
             },
             "require-dev": {
                 "facile-it/paraunit": "^1.3 || ^2.0",
                 "justinrainbow/json-schema": "^5.2",
-                "keradus/cli-executor": "^2.0",
+                "keradus/cli-executor": "^2.1",
                 "mikey179/vfsstream": "^1.6.11",
-                "php-coveralls/php-coveralls": "^2.5.3",
+                "php-coveralls/php-coveralls": "^2.7",
                 "php-cs-fixer/accessible-object": "^1.1",
-                "php-cs-fixer/phpunit-constraint-isidenticalstring": "^1.2",
-                "php-cs-fixer/phpunit-constraint-xmlmatchesxsd": "^1.2.1",
-                "phpspec/prophecy": "^1.16",
-                "phpspec/prophecy-phpunit": "^2.0",
-                "phpunit/phpunit": "^9.5",
-                "phpunitgoodpractices/polyfill": "^1.6",
-                "phpunitgoodpractices/traits": "^1.9.2",
-                "symfony/phpunit-bridge": "^6.2.3",
-                "symfony/yaml": "^5.4 || ^6.0"
+                "php-cs-fixer/phpunit-constraint-isidenticalstring": "^1.4",
+                "php-cs-fixer/phpunit-constraint-xmlmatchesxsd": "^1.4",
+                "phpunit/phpunit": "^9.6",
+                "symfony/yaml": "^5.4 || ^6.0 || ^7.0"
             },
             "suggest": {
                 "ext-dom": "For handling output formats in XML",
@@ -1170,7 +1169,7 @@
             ],
             "support": {
                 "issues": "https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/issues",
-                "source": "https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/tree/v3.31.0"
+                "source": "https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/tree/v3.42.0"
             },
             "funding": [
                 {
@@ -1178,7 +1177,7 @@
                     "type": "github"
                 }
             ],
-            "time": "2023-09-29T12:40:05+00:00"
+            "time": "2023-12-24T14:38:51+00:00"
         },
         {
             "name": "myclabs/deep-copy",
@@ -1241,16 +1240,16 @@
         },
         {
             "name": "nikic/php-parser",
-            "version": "v4.17.1",
+            "version": "v4.18.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/nikic/PHP-Parser.git",
-                "reference": "a6303e50c90c355c7eeee2c4a8b27fe8dc8fef1d"
+                "reference": "1bcbb2179f97633e98bbbc87044ee2611c7d7999"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/nikic/PHP-Parser/zipball/a6303e50c90c355c7eeee2c4a8b27fe8dc8fef1d",
-                "reference": "a6303e50c90c355c7eeee2c4a8b27fe8dc8fef1d",
+                "url": "https://api.github.com/repos/nikic/PHP-Parser/zipball/1bcbb2179f97633e98bbbc87044ee2611c7d7999",
+                "reference": "1bcbb2179f97633e98bbbc87044ee2611c7d7999",
                 "shasum": ""
             },
             "require": {
@@ -1291,9 +1290,9 @@
             ],
             "support": {
                 "issues": "https://github.com/nikic/PHP-Parser/issues",
-                "source": "https://github.com/nikic/PHP-Parser/tree/v4.17.1"
+                "source": "https://github.com/nikic/PHP-Parser/tree/v4.18.0"
             },
-            "time": "2023-08-13T19:53:39+00:00"
+            "time": "2023-12-10T21:03:43+00:00"
         },
         {
             "name": "phar-io/manifest",
@@ -1408,16 +1407,16 @@
         },
         {
             "name": "phpstan/phpstan",
-            "version": "1.10.35",
+            "version": "1.10.50",
             "source": {
                 "type": "git",
                 "url": "https://github.com/phpstan/phpstan.git",
-                "reference": "e730e5facb75ffe09dfb229795e8c01a459f26c3"
+                "reference": "06a98513ac72c03e8366b5a0cb00750b487032e4"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/phpstan/phpstan/zipball/e730e5facb75ffe09dfb229795e8c01a459f26c3",
-                "reference": "e730e5facb75ffe09dfb229795e8c01a459f26c3",
+                "url": "https://api.github.com/repos/phpstan/phpstan/zipball/06a98513ac72c03e8366b5a0cb00750b487032e4",
+                "reference": "06a98513ac72c03e8366b5a0cb00750b487032e4",
                 "shasum": ""
             },
             "require": {
@@ -1466,27 +1465,27 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2023-09-19T15:27:56+00:00"
+            "time": "2023-12-13T10:59:42+00:00"
         },
         {
             "name": "phpunit/php-code-coverage",
-            "version": "10.1.6",
+            "version": "10.1.11",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/php-code-coverage.git",
-                "reference": "56f33548fe522c8d82da7ff3824b42829d324364"
+                "reference": "78c3b7625965c2513ee96569a4dbb62601784145"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/56f33548fe522c8d82da7ff3824b42829d324364",
-                "reference": "56f33548fe522c8d82da7ff3824b42829d324364",
+                "url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/78c3b7625965c2513ee96569a4dbb62601784145",
+                "reference": "78c3b7625965c2513ee96569a4dbb62601784145",
                 "shasum": ""
             },
             "require": {
                 "ext-dom": "*",
                 "ext-libxml": "*",
                 "ext-xmlwriter": "*",
-                "nikic/php-parser": "^4.15",
+                "nikic/php-parser": "^4.18 || ^5.0",
                 "php": ">=8.1",
                 "phpunit/php-file-iterator": "^4.0",
                 "phpunit/php-text-template": "^3.0",
@@ -1536,7 +1535,7 @@
             "support": {
                 "issues": "https://github.com/sebastianbergmann/php-code-coverage/issues",
                 "security": "https://github.com/sebastianbergmann/php-code-coverage/security/policy",
-                "source": "https://github.com/sebastianbergmann/php-code-coverage/tree/10.1.6"
+                "source": "https://github.com/sebastianbergmann/php-code-coverage/tree/10.1.11"
             },
             "funding": [
                 {
@@ -1544,7 +1543,7 @@
                     "type": "github"
                 }
             ],
-            "time": "2023-09-19T04:59:03+00:00"
+            "time": "2023-12-21T15:38:30+00:00"
         },
         {
             "name": "phpunit/php-file-iterator",
@@ -1791,16 +1790,16 @@
         },
         {
             "name": "phpunit/phpunit",
-            "version": "10.3.5",
+            "version": "10.5.3",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/phpunit.git",
-                "reference": "747c3b2038f1139e3dcd9886a3f5a948648b7503"
+                "reference": "6fce887c71076a73f32fd3e0774a6833fc5c7f19"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/747c3b2038f1139e3dcd9886a3f5a948648b7503",
-                "reference": "747c3b2038f1139e3dcd9886a3f5a948648b7503",
+                "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/6fce887c71076a73f32fd3e0774a6833fc5c7f19",
+                "reference": "6fce887c71076a73f32fd3e0774a6833fc5c7f19",
                 "shasum": ""
             },
             "require": {
@@ -1840,7 +1839,7 @@
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-main": "10.3-dev"
+                    "dev-main": "10.5-dev"
                 }
             },
             "autoload": {
@@ -1872,7 +1871,7 @@
             "support": {
                 "issues": "https://github.com/sebastianbergmann/phpunit/issues",
                 "security": "https://github.com/sebastianbergmann/phpunit/security/policy",
-                "source": "https://github.com/sebastianbergmann/phpunit/tree/10.3.5"
+                "source": "https://github.com/sebastianbergmann/phpunit/tree/10.5.3"
             },
             "funding": [
                 {
@@ -1888,7 +1887,7 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2023-09-19T05:42:37+00:00"
+            "time": "2023-12-13T07:25:23+00:00"
         },
         {
             "name": "psr/event-dispatcher",
@@ -1942,21 +1941,21 @@
         },
         {
             "name": "rector/rector",
-            "version": "0.18.4",
+            "version": "0.18.13",
             "source": {
                 "type": "git",
                 "url": "https://github.com/rectorphp/rector.git",
-                "reference": "d99a91176b7eb7f2b6d509a6486b3661c6dfd370"
+                "reference": "f8011a76d36aa4f839f60f3b4f97707d97176618"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/rectorphp/rector/zipball/d99a91176b7eb7f2b6d509a6486b3661c6dfd370",
-                "reference": "d99a91176b7eb7f2b6d509a6486b3661c6dfd370",
+                "url": "https://api.github.com/repos/rectorphp/rector/zipball/f8011a76d36aa4f839f60f3b4f97707d97176618",
+                "reference": "f8011a76d36aa4f839f60f3b4f97707d97176618",
                 "shasum": ""
             },
             "require": {
                 "php": "^7.2|^8.0",
-                "phpstan/phpstan": "^1.10.31"
+                "phpstan/phpstan": "^1.10.35"
             },
             "conflict": {
                 "rector/rector-doctrine": "*",
@@ -1986,7 +1985,7 @@
             ],
             "support": {
                 "issues": "https://github.com/rectorphp/rector/issues",
-                "source": "https://github.com/rectorphp/rector/tree/0.18.4"
+                "source": "https://github.com/rectorphp/rector/tree/0.18.13"
             },
             "funding": [
                 {
@@ -1994,7 +1993,7 @@
                     "type": "github"
                 }
             ],
-            "time": "2023-09-25T17:07:54+00:00"
+            "time": "2023-12-20T16:08:01+00:00"
         },
         {
             "name": "sebastian/cli-parser",
@@ -2242,20 +2241,20 @@
         },
         {
             "name": "sebastian/complexity",
-            "version": "3.1.0",
+            "version": "3.2.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/complexity.git",
-                "reference": "68cfb347a44871f01e33ab0ef8215966432f6957"
+                "reference": "68ff824baeae169ec9f2137158ee529584553799"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/complexity/zipball/68cfb347a44871f01e33ab0ef8215966432f6957",
-                "reference": "68cfb347a44871f01e33ab0ef8215966432f6957",
+                "url": "https://api.github.com/repos/sebastianbergmann/complexity/zipball/68ff824baeae169ec9f2137158ee529584553799",
+                "reference": "68ff824baeae169ec9f2137158ee529584553799",
                 "shasum": ""
             },
             "require": {
-                "nikic/php-parser": "^4.10",
+                "nikic/php-parser": "^4.18 || ^5.0",
                 "php": ">=8.1"
             },
             "require-dev": {
@@ -2264,7 +2263,7 @@
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-main": "3.1-dev"
+                    "dev-main": "3.2-dev"
                 }
             },
             "autoload": {
@@ -2288,7 +2287,7 @@
             "support": {
                 "issues": "https://github.com/sebastianbergmann/complexity/issues",
                 "security": "https://github.com/sebastianbergmann/complexity/security/policy",
-                "source": "https://github.com/sebastianbergmann/complexity/tree/3.1.0"
+                "source": "https://github.com/sebastianbergmann/complexity/tree/3.2.0"
             },
             "funding": [
                 {
@@ -2296,20 +2295,20 @@
                     "type": "github"
                 }
             ],
-            "time": "2023-09-28T11:50:59+00:00"
+            "time": "2023-12-21T08:37:17+00:00"
         },
         {
             "name": "sebastian/diff",
-            "version": "5.0.3",
+            "version": "5.1.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/diff.git",
-                "reference": "912dc2fbe3e3c1e7873313cc801b100b6c68c87b"
+                "reference": "fbf413a49e54f6b9b17e12d900ac7f6101591b7f"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/diff/zipball/912dc2fbe3e3c1e7873313cc801b100b6c68c87b",
-                "reference": "912dc2fbe3e3c1e7873313cc801b100b6c68c87b",
+                "url": "https://api.github.com/repos/sebastianbergmann/diff/zipball/fbf413a49e54f6b9b17e12d900ac7f6101591b7f",
+                "reference": "fbf413a49e54f6b9b17e12d900ac7f6101591b7f",
                 "shasum": ""
             },
             "require": {
@@ -2322,7 +2321,7 @@
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-main": "5.0-dev"
+                    "dev-main": "5.1-dev"
                 }
             },
             "autoload": {
@@ -2355,7 +2354,7 @@
             "support": {
                 "issues": "https://github.com/sebastianbergmann/diff/issues",
                 "security": "https://github.com/sebastianbergmann/diff/security/policy",
-                "source": "https://github.com/sebastianbergmann/diff/tree/5.0.3"
+                "source": "https://github.com/sebastianbergmann/diff/tree/5.1.0"
             },
             "funding": [
                 {
@@ -2363,7 +2362,7 @@
                     "type": "github"
                 }
             ],
-            "time": "2023-05-01T07:48:21+00:00"
+            "time": "2023-12-22T10:55:06+00:00"
         },
         {
             "name": "sebastian/environment",
@@ -2571,20 +2570,20 @@
         },
         {
             "name": "sebastian/lines-of-code",
-            "version": "2.0.1",
+            "version": "2.0.2",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/lines-of-code.git",
-                "reference": "649e40d279e243d985aa8fb6e74dd5bb28dc185d"
+                "reference": "856e7f6a75a84e339195d48c556f23be2ebf75d0"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/lines-of-code/zipball/649e40d279e243d985aa8fb6e74dd5bb28dc185d",
-                "reference": "649e40d279e243d985aa8fb6e74dd5bb28dc185d",
+                "url": "https://api.github.com/repos/sebastianbergmann/lines-of-code/zipball/856e7f6a75a84e339195d48c556f23be2ebf75d0",
+                "reference": "856e7f6a75a84e339195d48c556f23be2ebf75d0",
                 "shasum": ""
             },
             "require": {
-                "nikic/php-parser": "^4.10",
+                "nikic/php-parser": "^4.18 || ^5.0",
                 "php": ">=8.1"
             },
             "require-dev": {
@@ -2617,7 +2616,7 @@
             "support": {
                 "issues": "https://github.com/sebastianbergmann/lines-of-code/issues",
                 "security": "https://github.com/sebastianbergmann/lines-of-code/security/policy",
-                "source": "https://github.com/sebastianbergmann/lines-of-code/tree/2.0.1"
+                "source": "https://github.com/sebastianbergmann/lines-of-code/tree/2.0.2"
             },
             "funding": [
                 {
@@ -2625,7 +2624,7 @@
                     "type": "github"
                 }
             ],
-            "time": "2023-08-31T09:25:50+00:00"
+            "time": "2023-12-21T08:38:20+00:00"
         },
         {
             "name": "sebastian/object-enumerator",
@@ -2913,16 +2912,16 @@
         },
         {
             "name": "squizlabs/php_codesniffer",
-            "version": "3.7.2",
+            "version": "3.8.0",
             "source": {
                 "type": "git",
-                "url": "https://github.com/squizlabs/PHP_CodeSniffer.git",
-                "reference": "ed8e00df0a83aa96acf703f8c2979ff33341f879"
+                "url": "https://github.com/PHPCSStandards/PHP_CodeSniffer.git",
+                "reference": "5805f7a4e4958dbb5e944ef1e6edae0a303765e7"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/squizlabs/PHP_CodeSniffer/zipball/ed8e00df0a83aa96acf703f8c2979ff33341f879",
-                "reference": "ed8e00df0a83aa96acf703f8c2979ff33341f879",
+                "url": "https://api.github.com/repos/PHPCSStandards/PHP_CodeSniffer/zipball/5805f7a4e4958dbb5e944ef1e6edae0a303765e7",
+                "reference": "5805f7a4e4958dbb5e944ef1e6edae0a303765e7",
                 "shasum": ""
             },
             "require": {
@@ -2932,7 +2931,7 @@
                 "php": ">=5.4.0"
             },
             "require-dev": {
-                "phpunit/phpunit": "^4.0 || ^5.0 || ^6.0 || ^7.0"
+                "phpunit/phpunit": "^4.0 || ^5.0 || ^6.0 || ^7.0 || ^8.0 || ^9.0"
             },
             "bin": [
                 "bin/phpcs",
@@ -2951,43 +2950,66 @@
             "authors": [
                 {
                     "name": "Greg Sherwood",
-                    "role": "lead"
+                    "role": "Former lead"
+                },
+                {
+                    "name": "Juliette Reinders Folmer",
+                    "role": "Current lead"
+                },
+                {
+                    "name": "Contributors",
+                    "homepage": "https://github.com/PHPCSStandards/PHP_CodeSniffer/graphs/contributors"
                 }
             ],
             "description": "PHP_CodeSniffer tokenizes PHP, JavaScript and CSS files and detects violations of a defined set of coding standards.",
-            "homepage": "https://github.com/squizlabs/PHP_CodeSniffer",
+            "homepage": "https://github.com/PHPCSStandards/PHP_CodeSniffer",
             "keywords": [
                 "phpcs",
                 "standards",
                 "static analysis"
             ],
             "support": {
-                "issues": "https://github.com/squizlabs/PHP_CodeSniffer/issues",
-                "source": "https://github.com/squizlabs/PHP_CodeSniffer",
-                "wiki": "https://github.com/squizlabs/PHP_CodeSniffer/wiki"
+                "issues": "https://github.com/PHPCSStandards/PHP_CodeSniffer/issues",
+                "security": "https://github.com/PHPCSStandards/PHP_CodeSniffer/security/policy",
+                "source": "https://github.com/PHPCSStandards/PHP_CodeSniffer",
+                "wiki": "https://github.com/PHPCSStandards/PHP_CodeSniffer/wiki"
             },
-            "time": "2023-02-22T23:07:41+00:00"
+            "funding": [
+                {
+                    "url": "https://github.com/PHPCSStandards",
+                    "type": "github"
+                },
+                {
+                    "url": "https://github.com/jrfnl",
+                    "type": "github"
+                },
+                {
+                    "url": "https://opencollective.com/php_codesniffer",
+                    "type": "open_collective"
+                }
+            ],
+            "time": "2023-12-08T12:32:31+00:00"
         },
         {
             "name": "symfony/event-dispatcher",
-            "version": "v6.3.2",
+            "version": "v7.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/event-dispatcher.git",
-                "reference": "adb01fe097a4ee930db9258a3cc906b5beb5cf2e"
+                "reference": "c459b40ffe67c49af6fd392aac374c9edf8a027e"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/event-dispatcher/zipball/adb01fe097a4ee930db9258a3cc906b5beb5cf2e",
-                "reference": "adb01fe097a4ee930db9258a3cc906b5beb5cf2e",
+                "url": "https://api.github.com/repos/symfony/event-dispatcher/zipball/c459b40ffe67c49af6fd392aac374c9edf8a027e",
+                "reference": "c459b40ffe67c49af6fd392aac374c9edf8a027e",
                 "shasum": ""
             },
             "require": {
-                "php": ">=8.1",
+                "php": ">=8.2",
                 "symfony/event-dispatcher-contracts": "^2.5|^3"
             },
             "conflict": {
-                "symfony/dependency-injection": "<5.4",
+                "symfony/dependency-injection": "<6.4",
                 "symfony/service-contracts": "<2.5"
             },
             "provide": {
@@ -2996,13 +3018,13 @@
             },
             "require-dev": {
                 "psr/log": "^1|^2|^3",
-                "symfony/config": "^5.4|^6.0",
-                "symfony/dependency-injection": "^5.4|^6.0",
-                "symfony/error-handler": "^5.4|^6.0",
-                "symfony/expression-language": "^5.4|^6.0",
-                "symfony/http-foundation": "^5.4|^6.0",
+                "symfony/config": "^6.4|^7.0",
+                "symfony/dependency-injection": "^6.4|^7.0",
+                "symfony/error-handler": "^6.4|^7.0",
+                "symfony/expression-language": "^6.4|^7.0",
+                "symfony/http-foundation": "^6.4|^7.0",
                 "symfony/service-contracts": "^2.5|^3",
-                "symfony/stopwatch": "^5.4|^6.0"
+                "symfony/stopwatch": "^6.4|^7.0"
             },
             "type": "library",
             "autoload": {
@@ -3030,7 +3052,7 @@
             "description": "Provides tools that allow your application components to communicate with each other by dispatching events and listening to them",
             "homepage": "https://symfony.com",
             "support": {
-                "source": "https://github.com/symfony/event-dispatcher/tree/v6.3.2"
+                "source": "https://github.com/symfony/event-dispatcher/tree/v7.0.0"
             },
             "funding": [
                 {
@@ -3046,11 +3068,11 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2023-07-06T06:56:43+00:00"
+            "time": "2023-07-27T16:29:09+00:00"
         },
         {
             "name": "symfony/event-dispatcher-contracts",
-            "version": "v3.3.0",
+            "version": "v3.4.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/event-dispatcher-contracts.git",
@@ -3106,7 +3128,7 @@
                 "standards"
             ],
             "support": {
-                "source": "https://github.com/symfony/event-dispatcher-contracts/tree/v3.3.0"
+                "source": "https://github.com/symfony/event-dispatcher-contracts/tree/v3.4.0"
             },
             "funding": [
                 {
@@ -3126,20 +3148,20 @@
         },
         {
             "name": "symfony/filesystem",
-            "version": "v6.3.1",
+            "version": "v7.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/filesystem.git",
-                "reference": "edd36776956f2a6fcf577edb5b05eb0e3bdc52ae"
+                "reference": "7da8ea2362a283771478c5f7729cfcb43a76b8b7"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/filesystem/zipball/edd36776956f2a6fcf577edb5b05eb0e3bdc52ae",
-                "reference": "edd36776956f2a6fcf577edb5b05eb0e3bdc52ae",
+                "url": "https://api.github.com/repos/symfony/filesystem/zipball/7da8ea2362a283771478c5f7729cfcb43a76b8b7",
+                "reference": "7da8ea2362a283771478c5f7729cfcb43a76b8b7",
                 "shasum": ""
             },
             "require": {
-                "php": ">=8.1",
+                "php": ">=8.2",
                 "symfony/polyfill-ctype": "~1.8",
                 "symfony/polyfill-mbstring": "~1.8"
             },
@@ -3169,7 +3191,7 @@
             "description": "Provides basic utilities for the filesystem",
             "homepage": "https://symfony.com",
             "support": {
-                "source": "https://github.com/symfony/filesystem/tree/v6.3.1"
+                "source": "https://github.com/symfony/filesystem/tree/v7.0.0"
             },
             "funding": [
                 {
@@ -3185,27 +3207,27 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2023-06-01T08:30:39+00:00"
+            "time": "2023-07-27T06:33:22+00:00"
         },
         {
             "name": "symfony/finder",
-            "version": "v6.3.3",
+            "version": "v7.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/finder.git",
-                "reference": "9915db259f67d21eefee768c1abcf1cc61b1fc9e"
+                "reference": "6e5688d69f7cfc4ed4a511e96007e06c2d34ce56"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/finder/zipball/9915db259f67d21eefee768c1abcf1cc61b1fc9e",
-                "reference": "9915db259f67d21eefee768c1abcf1cc61b1fc9e",
+                "url": "https://api.github.com/repos/symfony/finder/zipball/6e5688d69f7cfc4ed4a511e96007e06c2d34ce56",
+                "reference": "6e5688d69f7cfc4ed4a511e96007e06c2d34ce56",
                 "shasum": ""
             },
             "require": {
-                "php": ">=8.1"
+                "php": ">=8.2"
             },
             "require-dev": {
-                "symfony/filesystem": "^6.0"
+                "symfony/filesystem": "^6.4|^7.0"
             },
             "type": "library",
             "autoload": {
@@ -3233,7 +3255,7 @@
             "description": "Finds files and directories via an intuitive fluent interface",
             "homepage": "https://symfony.com",
             "support": {
-                "source": "https://github.com/symfony/finder/tree/v6.3.3"
+                "source": "https://github.com/symfony/finder/tree/v7.0.0"
             },
             "funding": [
                 {
@@ -3249,24 +3271,24 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2023-07-31T08:31:44+00:00"
+            "time": "2023-10-31T17:59:56+00:00"
         },
         {
             "name": "symfony/options-resolver",
-            "version": "v6.3.0",
+            "version": "v7.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/options-resolver.git",
-                "reference": "a10f19f5198d589d5c33333cffe98dc9820332dd"
+                "reference": "700ff4096e346f54cb628ea650767c8130f1001f"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/options-resolver/zipball/a10f19f5198d589d5c33333cffe98dc9820332dd",
-                "reference": "a10f19f5198d589d5c33333cffe98dc9820332dd",
+                "url": "https://api.github.com/repos/symfony/options-resolver/zipball/700ff4096e346f54cb628ea650767c8130f1001f",
+                "reference": "700ff4096e346f54cb628ea650767c8130f1001f",
                 "shasum": ""
             },
             "require": {
-                "php": ">=8.1",
+                "php": ">=8.2",
                 "symfony/deprecation-contracts": "^2.5|^3"
             },
             "type": "library",
@@ -3300,7 +3322,7 @@
                 "options"
             ],
             "support": {
-                "source": "https://github.com/symfony/options-resolver/tree/v6.3.0"
+                "source": "https://github.com/symfony/options-resolver/tree/v7.0.0"
             },
             "funding": [
                 {
@@ -3316,7 +3338,7 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2023-05-12T14:21:09+00:00"
+            "time": "2023-08-08T10:20:21+00:00"
         },
         {
             "name": "symfony/polyfill-php80",
@@ -3482,20 +3504,20 @@
         },
         {
             "name": "symfony/process",
-            "version": "v6.3.4",
+            "version": "v7.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/process.git",
-                "reference": "0b5c29118f2e980d455d2e34a5659f4579847c54"
+                "reference": "13bdb1670c7f510494e04fcb2bfa29af63db9c0d"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/process/zipball/0b5c29118f2e980d455d2e34a5659f4579847c54",
-                "reference": "0b5c29118f2e980d455d2e34a5659f4579847c54",
+                "url": "https://api.github.com/repos/symfony/process/zipball/13bdb1670c7f510494e04fcb2bfa29af63db9c0d",
+                "reference": "13bdb1670c7f510494e04fcb2bfa29af63db9c0d",
                 "shasum": ""
             },
             "require": {
-                "php": ">=8.1"
+                "php": ">=8.2"
             },
             "type": "library",
             "autoload": {
@@ -3523,7 +3545,7 @@
             "description": "Executes commands in sub-processes",
             "homepage": "https://symfony.com",
             "support": {
-                "source": "https://github.com/symfony/process/tree/v6.3.4"
+                "source": "https://github.com/symfony/process/tree/v7.0.0"
             },
             "funding": [
                 {
@@ -3539,24 +3561,24 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2023-08-07T10:39:22+00:00"
+            "time": "2023-11-20T16:43:42+00:00"
         },
         {
             "name": "symfony/stopwatch",
-            "version": "v6.3.0",
+            "version": "v7.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/stopwatch.git",
-                "reference": "fc47f1015ec80927ff64ba9094dfe8b9d48fe9f2"
+                "reference": "7bbfa3dd564a0ce12eb4acaaa46823c740f9cb7a"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/stopwatch/zipball/fc47f1015ec80927ff64ba9094dfe8b9d48fe9f2",
-                "reference": "fc47f1015ec80927ff64ba9094dfe8b9d48fe9f2",
+                "url": "https://api.github.com/repos/symfony/stopwatch/zipball/7bbfa3dd564a0ce12eb4acaaa46823c740f9cb7a",
+                "reference": "7bbfa3dd564a0ce12eb4acaaa46823c740f9cb7a",
                 "shasum": ""
             },
             "require": {
-                "php": ">=8.1",
+                "php": ">=8.2",
                 "symfony/service-contracts": "^2.5|^3"
             },
             "type": "library",
@@ -3585,7 +3607,7 @@
             "description": "Provides a way to profile code",
             "homepage": "https://symfony.com",
             "support": {
-                "source": "https://github.com/symfony/stopwatch/tree/v6.3.0"
+                "source": "https://github.com/symfony/stopwatch/tree/v7.0.0"
             },
             "funding": [
                 {
@@ -3601,20 +3623,20 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2023-02-16T10:14:28+00:00"
+            "time": "2023-07-05T13:06:06+00:00"
         },
         {
             "name": "theseer/tokenizer",
-            "version": "1.2.1",
+            "version": "1.2.2",
             "source": {
                 "type": "git",
                 "url": "https://github.com/theseer/tokenizer.git",
-                "reference": "34a41e998c2183e22995f158c581e7b5e755ab9e"
+                "reference": "b2ad5003ca10d4ee50a12da31de12a5774ba6b96"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/theseer/tokenizer/zipball/34a41e998c2183e22995f158c581e7b5e755ab9e",
-                "reference": "34a41e998c2183e22995f158c581e7b5e755ab9e",
+                "url": "https://api.github.com/repos/theseer/tokenizer/zipball/b2ad5003ca10d4ee50a12da31de12a5774ba6b96",
+                "reference": "b2ad5003ca10d4ee50a12da31de12a5774ba6b96",
                 "shasum": ""
             },
             "require": {
@@ -3643,7 +3665,7 @@
             "description": "A small library for converting tokenized PHP source code into XML and potentially other formats",
             "support": {
                 "issues": "https://github.com/theseer/tokenizer/issues",
-                "source": "https://github.com/theseer/tokenizer/tree/1.2.1"
+                "source": "https://github.com/theseer/tokenizer/tree/1.2.2"
             },
             "funding": [
                 {
@@ -3651,7 +3673,7 @@
                     "type": "github"
                 }
             ],
-            "time": "2021-07-28T10:34:58+00:00"
+            "time": "2023-11-20T00:12:19+00:00"
         }
     ],
     "aliases": [],
diff --git a/rector.php b/rector.php
index 827fd244..9366d451 100644
--- a/rector.php
+++ b/rector.php
@@ -31,7 +31,6 @@
     $rectorConfig->rule(\Rector\Strict\Rector\Ternary\BooleanInTernaryOperatorRuleFixerRector::class);
     $rectorConfig->rule(\Rector\Strict\Rector\Empty_\DisallowedEmptyRuleFixerRector::class);
     $rectorConfig->rule(\Rector\Strict\Rector\Ternary\DisallowedShortTernaryRuleFixerRector::class);
-    $rectorConfig->rule(\Rector\CodingStyle\Rector\Switch_\BinarySwitchToIfElseRector::class);
     $rectorConfig->rule(\Rector\CodingStyle\Rector\FuncCall\CallUserFuncArrayToVariadicRector::class);
     $rectorConfig->rule(\Rector\CodingStyle\Rector\FuncCall\CallUserFuncToMethodCallRector::class);
     $rectorConfig->rule(\Rector\CodingStyle\Rector\FuncCall\ConsistentImplodeRector::class);
diff --git a/src/VM/Core/Criterion/Entry/AbstractEntries.php b/src/VM/Core/Criterion/Entry/AbstractEntries.php
index 7cb05c81..a23c2980 100644
--- a/src/VM/Core/Criterion/Entry/AbstractEntries.php
+++ b/src/VM/Core/Criterion/Entry/AbstractEntries.php
@@ -107,12 +107,12 @@ public function getIterator(): \ArrayIterator
         return new \ArrayIterator($this->items);
     }
 
-    protected function filterKeyName(mixed $index): string|int|null
+    protected function filterKeyName(mixed $index): null|int|string
     {
         return $this->enumToName($index);
     }
 
-    private function enumToName(mixed $index): string|int
+    private function enumToName(mixed $index): int|string
     {
         if (is_object($index) && enum_exists($index::class, false)) {
             // @phpstan-ignore-next-line
diff --git a/src/VM/Core/Runtime/BasicObject/BasicObject.php b/src/VM/Core/Runtime/BasicObject/BasicObject.php
index 4595dd13..48f90d04 100644
--- a/src/VM/Core/Runtime/BasicObject/BasicObject.php
+++ b/src/VM/Core/Runtime/BasicObject/BasicObject.php
@@ -45,7 +45,7 @@ public function __toString(): string
     /**
      * @param (null|ContextInterface|RubyClassInterface)[] $arguments
      */
-    public function __call(string $name, array $arguments): ExecutedResult|RubyClassInterface|null
+    public function __call(string $name, array $arguments): null|ExecutedResult|RubyClassInterface
     {
         try {
             $result = $this->callExtendedMethod($name, $arguments);
diff --git a/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Comparable/Integer_.php b/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Comparable/Integer_.php
index 3304b7f8..935401bf 100644
--- a/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Comparable/Integer_.php
+++ b/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Comparable/Integer_.php
@@ -59,7 +59,7 @@ public function leftShift(RubyClassInterface $object): Integer_
     }
 
     #[BindAliasAs('===')]
-    public function compareStrictEquals(RubyClassInterface $object): TrueClass|FalseClass
+    public function compareStrictEquals(RubyClassInterface $object): FalseClass|TrueClass
     {
         return $this->valueOf() === $object->valueOf()
             ? TrueClass::createBy()
@@ -145,7 +145,7 @@ public function mod(RubyClassInterface $object): Integer_
     }
 
     #[BindAliasAs('==')]
-    public function equals(RubyClassInterface $object): TrueClass|FalseClass
+    public function equals(RubyClassInterface $object): FalseClass|TrueClass
     {
         return $this->valueOf() == $object->valueOf()
             ? TrueClass::createBy()
@@ -153,7 +153,7 @@ public function equals(RubyClassInterface $object): TrueClass|FalseClass
     }
 
     #[BindAliasAs('<=')]
-    public function equalsOrLessThan(RubyClassInterface $object): TrueClass|FalseClass
+    public function equalsOrLessThan(RubyClassInterface $object): FalseClass|TrueClass
     {
         return $this->valueOf() <= $object->valueOf()
             ? TrueClass::createBy()
@@ -161,7 +161,7 @@ public function equalsOrLessThan(RubyClassInterface $object): TrueClass|FalseCla
     }
 
     #[BindAliasAs('>=')]
-    public function equalsOrGreaterThan(RubyClassInterface $object): TrueClass|FalseClass
+    public function equalsOrGreaterThan(RubyClassInterface $object): FalseClass|TrueClass
     {
         return $this->valueOf() >= $object->valueOf()
             ? TrueClass::createBy()
@@ -169,7 +169,7 @@ public function equalsOrGreaterThan(RubyClassInterface $object): TrueClass|False
     }
 
     #[BindAliasAs('<')]
-    public function lessThan(RubyClassInterface $object): TrueClass|FalseClass
+    public function lessThan(RubyClassInterface $object): FalseClass|TrueClass
     {
         return $this->valueOf() < $object->valueOf()
             ? TrueClass::createBy()
@@ -177,7 +177,7 @@ public function lessThan(RubyClassInterface $object): TrueClass|FalseClass
     }
 
     #[BindAliasAs('>')]
-    public function greaterThan(RubyClassInterface $object): TrueClass|FalseClass
+    public function greaterThan(RubyClassInterface $object): FalseClass|TrueClass
     {
         return $this->valueOf() > $object->valueOf()
             ? TrueClass::createBy()
@@ -185,7 +185,7 @@ public function greaterThan(RubyClassInterface $object): TrueClass|FalseClass
     }
 
     #[BindAliasAs('even?')]
-    public function isEven(): TrueClass|FalseClass
+    public function isEven(): FalseClass|TrueClass
     {
         return ($this->valueOf() & 1) === 0
             ? TrueClass::createBy()
@@ -193,7 +193,7 @@ public function isEven(): TrueClass|FalseClass
     }
 
     #[BindAliasAs('odd?')]
-    public function isOdd(): TrueClass|FalseClass
+    public function isOdd(): FalseClass|TrueClass
     {
         return ($this->valueOf() & 1) === 1
             ? TrueClass::createBy()
@@ -201,7 +201,7 @@ public function isOdd(): TrueClass|FalseClass
     }
 
     #[BindAliasAs('zero?')]
-    public function isZero(): TrueClass|FalseClass
+    public function isZero(): FalseClass|TrueClass
     {
         return $this->valueOf() === 0
             ? TrueClass::createBy()
diff --git a/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Comparable/String_.php b/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Comparable/String_.php
index 461dccd6..e6d18c82 100644
--- a/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Comparable/String_.php
+++ b/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Comparable/String_.php
@@ -41,7 +41,7 @@ public function plus(RubyClassInterface $object): String_
     }
 
     #[BindAliasAs('empty?')]
-    public function isEmpty(): TrueClass|FalseClass
+    public function isEmpty(): FalseClass|TrueClass
     {
         return $this->valueOf() === ''
             ? TrueClass::createBy()
@@ -49,7 +49,7 @@ public function isEmpty(): TrueClass|FalseClass
     }
 
     #[BindAliasAs('include?')]
-    public function isIncluding(String_ $string): TrueClass|FalseClass
+    public function isIncluding(String_ $string): FalseClass|TrueClass
     {
         return str_contains((string) $this->valueOf(), (string) $string->valueOf())
             ? TrueClass::createBy()
diff --git a/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Enumerable/Array_.php b/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Enumerable/Array_.php
index 90e8849d..ab6454a3 100644
--- a/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Enumerable/Array_.php
+++ b/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Enumerable/Array_.php
@@ -32,7 +32,7 @@ public function __construct(ArraySymbol $symbol)
     /**
      * @param RubyClassInterface|SymbolInterface[] $values
      */
-    public function new(RubyClassInterface|array $values = null): self
+    public function new(array|RubyClassInterface $values = null): self
     {
         $this->symbol = new ArraySymbol(
             $values instanceof RubyClassInterface
diff --git a/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Enumerable/Range.php b/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Enumerable/Range.php
index 5d4fd054..7c01eedd 100644
--- a/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Enumerable/Range.php
+++ b/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Enumerable/Range.php
@@ -120,7 +120,7 @@ public function count(): int
     }
 
     #[BindAliasAs('===')]
-    public function compareStrictEquals(RubyClassInterface $object): TrueClass|FalseClass
+    public function compareStrictEquals(RubyClassInterface $object): FalseClass|TrueClass
     {
         assert($this->symbol instanceof RangeSymbol);
 
diff --git a/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Object_.php b/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Object_.php
index a9849b14..b9a8f18b 100644
--- a/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Object_.php
+++ b/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Object_.php
@@ -10,7 +10,7 @@
 abstract class Object_ extends Kernel
 {
     #[BindAliasAs('nil?')]
-    public function isNil(): TrueClass|FalseClass
+    public function isNil(): FalseClass|TrueClass
     {
         return $this instanceof NilClass || $this->valueOf() === null
             ? TrueClass::createBy()
diff --git a/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Proc.php b/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Proc.php
index d991d82a..556282a2 100644
--- a/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Proc.php
+++ b/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Proc.php
@@ -24,7 +24,7 @@ public function new(?ContextInterface $procContext): RubyClassInterface
         return $this;
     }
 
-    public function call(RubyClassInterface ...$arguments): RubyClassInterface|null
+    public function call(RubyClassInterface ...$arguments): null|RubyClassInterface
     {
         if (!$this->procContext instanceof \RubyVM\VM\Core\Runtime\Executor\Context\ContextInterface) {
             return NilClass::createBy();
diff --git a/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Regexp.php b/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Regexp.php
index 21e87ea3..3d2f865c 100644
--- a/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Regexp.php
+++ b/src/VM/Core/Runtime/BasicObject/Kernel/Object_/Regexp.php
@@ -36,7 +36,7 @@ public function __toString(): string
      * @see https://docs.ruby-lang.org/ja/latest/class/Regexp.html#I_--3D--7E
      */
     #[BindAliasAs('=~')]
-    public function equalsTilde(String_|NilClass $source): Integer_|NilClass
+    public function equalsTilde(NilClass|String_ $source): Integer_|NilClass
     {
         if ($source instanceof NilClass) {
             return NilClass::createBy();
diff --git a/src/VM/Core/Runtime/Executor/Accessor/Translator.php b/src/VM/Core/Runtime/Executor/Accessor/Translator.php
index bc364c9a..c80a63eb 100644
--- a/src/VM/Core/Runtime/Executor/Accessor/Translator.php
+++ b/src/VM/Core/Runtime/Executor/Accessor/Translator.php
@@ -57,7 +57,7 @@ public static function PHPToRuby(mixed $elements): RubyClassInterface
     /**
      * @param (RubyClassInterface|SymbolInterface)[]|RubyClassInterface|SymbolInterface $objectOrClass
      */
-    public static function RubyToPHP(RubyClassInterface|SymbolInterface|array $objectOrClass): mixed
+    public static function RubyToPHP(array|RubyClassInterface|SymbolInterface $objectOrClass): mixed
     {
         if (is_array($objectOrClass)) {
             return array_map(
diff --git a/src/VM/Core/Runtime/Executor/CallBlockHelper.php b/src/VM/Core/Runtime/Executor/CallBlockHelper.php
index 059674fa..02b8aefb 100644
--- a/src/VM/Core/Runtime/Executor/CallBlockHelper.php
+++ b/src/VM/Core/Runtime/Executor/CallBlockHelper.php
@@ -146,7 +146,7 @@ private function callSimpleMethod(ContextInterface $context, CallInfoInterface $
      *
      * @return (ContextInterface|RubyClassInterface)[]
      */
-    private static function alignArguments(?CallInfoInterface $callInfo, ContextInterface $context, RubyClassInterface|ContextInterface|array ...$arguments): array
+    private static function alignArguments(?CallInfoInterface $callInfo, ContextInterface $context, array|ContextInterface|RubyClassInterface ...$arguments): array
     {
         // @phpstan-ignore-next-line
         return self::applyAlignmentArgumentsByKeywords(
@@ -166,7 +166,7 @@ private static function alignArguments(?CallInfoInterface $callInfo, ContextInte
      *
      * @return (array<ContextInterface|RubyClassInterface>[]|ContextInterface|RubyClassInterface)[]
      */
-    private static function applySplatExpression(ContextInterface $context, RubyClassInterface|ContextInterface|array ...$arguments): array
+    private static function applySplatExpression(ContextInterface $context, array|ContextInterface|RubyClassInterface ...$arguments): array
     {
         $newArguments = [];
         foreach ($arguments as $argument) {
@@ -189,7 +189,7 @@ private static function applySplatExpression(ContextInterface $context, RubyClas
      *
      * @return (array<ContextInterface|RubyClassInterface>[]|ContextInterface|RubyClassInterface)[]
      */
-    private static function applyAlignmentArgumentsByKeywords(?CallInfoInterface $callInfo, ContextInterface $context, RubyClassInterface|ContextInterface|array ...$arguments): array
+    private static function applyAlignmentArgumentsByKeywords(?CallInfoInterface $callInfo, ContextInterface $context, array|ContextInterface|RubyClassInterface ...$arguments): array
     {
         if (!$callInfo instanceof \RubyVM\VM\Core\YARV\Criterion\InstructionSequence\CallInfoInterface) {
             return $arguments;
diff --git a/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php b/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php
index 1556d1c3..66e8c18e 100644
--- a/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php
+++ b/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php
@@ -97,7 +97,7 @@ public function showExecutedOperations(): void
                 sprintf(
                     '[0x%02x] %s %s',
                     $insn->value,
-                    strtolower($insn->name),
+                    strtolower((string) $insn->name),
                     $insnDetails ? "({$insnDetails})" : '',
                 ),
                 (string) $context->vmStack(),
diff --git a/src/VM/Core/Runtime/Executor/Debugger/StepByStepDebugger.php b/src/VM/Core/Runtime/Executor/Debugger/StepByStepDebugger.php
index bbd4f061..b31cc71e 100644
--- a/src/VM/Core/Runtime/Executor/Debugger/StepByStepDebugger.php
+++ b/src/VM/Core/Runtime/Executor/Debugger/StepByStepDebugger.php
@@ -15,7 +15,7 @@ private function processBreakPoint(InsnInterface $insn, ContextInterface $prevCo
 
         printf(
             "Current INSN: %s(0x%02x)\n",
-            strtolower($insn->name),
+            strtolower((string) $insn->name),
             $insn->value,
         );
         printf(
diff --git a/src/VM/Core/Runtime/Executor/EnvironmentTable.php b/src/VM/Core/Runtime/Executor/EnvironmentTable.php
index 975dea25..14158876 100644
--- a/src/VM/Core/Runtime/Executor/EnvironmentTable.php
+++ b/src/VM/Core/Runtime/Executor/EnvironmentTable.php
@@ -95,7 +95,7 @@ public function __toString(): string
         );
     }
 
-    public function findBy(string $varName): RubyClassInterface|null
+    public function findBy(string $varName): null|RubyClassInterface
     {
         $pos = array_search($varName, $this->boundNames, true);
         if ($pos === false) {
diff --git a/src/VM/Core/Runtime/Executor/ExecutedResult.php b/src/VM/Core/Runtime/Executor/ExecutedResult.php
index 4973f706..5dcab83c 100644
--- a/src/VM/Core/Runtime/Executor/ExecutedResult.php
+++ b/src/VM/Core/Runtime/Executor/ExecutedResult.php
@@ -13,7 +13,7 @@
     public function __construct(
         public ExecutorInterface $executor,
         public ExecutedStatus $executedStatus,
-        public RubyClassInterface|null $returnValue = null,
+        public null|RubyClassInterface $returnValue = null,
         public ?\Throwable $threw = null,
     ) {}
 
diff --git a/src/VM/Core/Runtime/Executor/Executor.php b/src/VM/Core/Runtime/Executor/Executor.php
index f4f6b14c..18d45264 100644
--- a/src/VM/Core/Runtime/Executor/Executor.php
+++ b/src/VM/Core/Runtime/Executor/Executor.php
@@ -14,7 +14,6 @@
 use RubyVM\VM\Core\Runtime\Executor\Context\OperationProcessorContext;
 use RubyVM\VM\Core\Runtime\Executor\Context\ProgramCounter;
 use RubyVM\VM\Core\Runtime\Executor\Context\VMStack;
-use RubyVM\VM\Core\Runtime\Executor\Insn\InsnInterface;
 use RubyVM\VM\Core\Runtime\Executor\Operation\Operation;
 use RubyVM\VM\Core\Runtime\Main;
 use RubyVM\VM\Core\Runtime\Option;
@@ -192,7 +191,7 @@ private function _execute(ContextInterface|RubyClassInterface ...$arguments): Ex
             $this->option->logger()->info(
                 sprintf(
                     'Start to process an INSN `%s` (0x%02x) (ProgramCounter: %d)',
-                    strtolower($operator->insn->name),
+                    strtolower((string) $operator->insn->name),
                     $operator->insn->value,
                     $this->context->programCounter()->pos(),
                 ),
@@ -206,7 +205,7 @@ private function _execute(ContextInterface|RubyClassInterface ...$arguments): Ex
             $this->option->logger()->info(
                 sprintf(
                     'Start to prepare an INSN `%s` (0x%02x) (ProgramCounter: %d)',
-                    strtolower($operator->insn->name),
+                    strtolower((string) $operator->insn->name),
                     $operator->insn->value,
                     $this->context->programCounter()->pos(),
                 ),
@@ -223,7 +222,7 @@ private function _execute(ContextInterface|RubyClassInterface ...$arguments): Ex
             $this->option->logger()->info(
                 sprintf(
                     'Start to process a before method an INSN `%s` (0x%02x) (ProgramCounter: %d)',
-                    strtolower($operator->insn->name),
+                    strtolower((string) $operator->insn->name),
                     $operator->insn->value,
                     $this->context->programCounter()->pos(),
                 ),
@@ -234,7 +233,7 @@ private function _execute(ContextInterface|RubyClassInterface ...$arguments): Ex
             $this->option->logger()->info(
                 sprintf(
                     'Start to process a main routine method an INSN `%s` (0x%02x) (ProgramCounter: %d)',
-                    strtolower($operator->insn->name),
+                    strtolower((string) $operator->insn->name),
                     $operator->insn->value,
                     $this->context->programCounter()->pos(),
                 ),
@@ -253,7 +252,7 @@ private function _execute(ContextInterface|RubyClassInterface ...$arguments): Ex
             $this->option->logger()->info(
                 sprintf(
                     'Start to process a post method an INSN `%s` (0x%02x) (ProgramCounter: %d)',
-                    strtolower($operator->insn->name),
+                    strtolower((string) $operator->insn->name),
                     $operator->insn->value,
                     $this->context->programCounter()->pos(),
                 ),
@@ -292,7 +291,7 @@ private function _execute(ContextInterface|RubyClassInterface ...$arguments): Ex
                 'Illegal finish an executor',
             );
 
-            throw new ExecutorExeption(sprintf('The executor did not finish - maybe did not call the `%s` (0x%02x)', strtolower(Insn::LEAVE->name), Insn::LEAVE->value));
+            throw new ExecutorExeption(sprintf('The executor did not finish - maybe did not call the `%s` (0x%02x)', strtolower((string) Insn::LEAVE->name), Insn::LEAVE->value));
         }
 
         if (count($operations) !== $this->context->programCounter()->pos()) {
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAdjuststack.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAdjuststack.php
index 3f92afc3..2fa92e6b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAdjuststack.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAdjuststack.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAnytostring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAnytostring.php
index 542b8b88..e429cfea 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAnytostring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAnytostring.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchnil.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchnil.php
index 91a4a565..ecfc3fd0 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchnil.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchnil.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckkeyword.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckkeyword.php
index 0a665f59..50c35b61 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckkeyword.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckkeyword.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckmatch.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckmatch.php
index 1765a5a9..e630dffe 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckmatch.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckmatch.php
@@ -41,7 +41,7 @@ public function process(): ProcessedStatus
 
         // TODO: We will implement other types
         if ($type->valueOf() !== CheckMatchType::RESCUE->value) {
-            throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor with %d type is not implemented yet', strtolower($this->insn->name), $this->insn->value, $type->valueOf()));
+            throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor with %d type is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value, $type->valueOf()));
         }
 
         $compareBy = $this->stackAsRubyClass();
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinChecktype.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinChecktype.php
index e6b498d1..892eed51 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinChecktype.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinChecktype.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatstrings.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatstrings.php
index b13f96f3..81c89363 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatstrings.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatstrings.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinesmethod.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinesmethod.php
index 01859dc5..0f872621 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinesmethod.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinesmethod.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuphash.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuphash.php
index 471954eb..4d8256cf 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuphash.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuphash.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDupn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDupn.php
index bd4be721..1240ba35 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDupn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDupn.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinExpandarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinExpandarray.php
index 16108d66..cbcded0c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinExpandarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinExpandarray.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetclassvariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetclassvariable.php
index bc2c5ae4..a60aad4c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetclassvariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetclassvariable.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetconstant.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetconstant.php
index 73029dec..e8c0422b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetconstant.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetconstant.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetspecial.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetspecial.php
index f13c3db1..1e805b37 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetspecial.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetspecial.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinIntern.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinIntern.php
index f1617e0e..2be6cf8c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinIntern.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinIntern.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokebuiltin.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokebuiltin.php
index c091214c..9cc24259 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokebuiltin.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokebuiltin.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokesuper.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokesuper.php
index 0de4d5eb..41ffd6b1 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokesuper.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokesuper.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarraykwsplat.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarraykwsplat.php
index 8100068f..8e3f3dc6 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarraykwsplat.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarraykwsplat.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinObjtostring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinObjtostring.php
index efa161e8..1e569154 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinObjtostring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinObjtostring.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOnce.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOnce.php
index 3a7a7218..5c7f9269 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOnce.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOnce.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptArefWith.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptArefWith.php
index 2c3f5465..60242e76 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptArefWith.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptArefWith.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAset.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAset.php
index 8a2123d9..5e49ae9e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAset.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAset.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAsetWith.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAsetWith.php
index c913dd31..835815b5 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAsetWith.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAsetWith.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegate.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegate.php
index 08efa858..9a045ac4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegate.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegate.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegateLeave.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegateLeave.php
index 4488584e..030185aa 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegateLeave.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegateLeave.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLength.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLength.php
index 261d7b3d..61e48937 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLength.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLength.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNeq.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNeq.php
index a7b75e7a..e3da7aa3 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNeq.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNeq.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMax.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMax.php
index 4fc1a17c..6dfa259f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMax.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMax.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMin.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMin.php
index 4cae6468..f10e9cae 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMin.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMin.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNot.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNot.php
index fd5be3b1..c7f48b16 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNot.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNot.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptReverse.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptReverse.php
index 0518fe3d..ad397221 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptReverse.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptReverse.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSize.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSize.php
index e2c82d89..816aceac 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSize.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSize.php
@@ -51,6 +51,6 @@ public function process(): ProcessedStatus
             return ProcessedStatus::SUCCESS;
         }
 
-        throw new OperationProcessorException(sprintf('The %s is not compatible type %s', strtolower($this->insn->name), ClassHelper::nameBy($recv)));
+        throw new OperationProcessorException(sprintf('The %s is not compatible type %s', strtolower((string) $this->insn->name), ClassHelper::nameBy($recv)));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrFreeze.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrFreeze.php
index b6523d14..c9f5eba4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrFreeze.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrFreeze.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrUminus.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrUminus.php
index 17a5b1f1..0dccfdde 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrUminus.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrUminus.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSucc.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSucc.php
index 81fad812..4cfc13a2 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSucc.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSucc.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetblockparam.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetblockparam.php
index 9c935f2d..c4abd7f5 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetblockparam.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetblockparam.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetclassvariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetclassvariable.php
index 51aeab2d..91482a04 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetclassvariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetclassvariable.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetconstant.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetconstant.php
index 6d678ef2..63d1ee38 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetconstant.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetconstant.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetn.php
index 59692585..1e775325 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetn.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetspecial.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetspecial.php
index 4ee186e4..9b0c84e0 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetspecial.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetspecial.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSwap.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSwap.php
index ea9672ba..cbcaf957 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSwap.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSwap.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinThrow.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinThrow.php
index 8e5ff2b6..58af5453 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinThrow.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinThrow.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinToregexp.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinToregexp.php
index a2b67bef..83db7f51 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinToregexp.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinToregexp.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAdjuststack.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAdjuststack.php
index 8107aad7..1f04abbc 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAdjuststack.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAdjuststack.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAnytostring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAnytostring.php
index 7870f538..ff0b44fc 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAnytostring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAnytostring.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchif.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchif.php
index bd10dd87..49fade20 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchif.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchif.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchnil.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchnil.php
index 451e36bc..73882504 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchnil.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchnil.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchunless.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchunless.php
index 472c4899..f3e88a0d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchunless.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchunless.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckkeyword.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckkeyword.php
index c940e317..2d0481c2 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckkeyword.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckkeyword.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckmatch.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckmatch.php
index 62828bcc..9afee2dd 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckmatch.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckmatch.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceChecktype.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceChecktype.php
index 5ba1f661..4863df21 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceChecktype.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceChecktype.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatarray.php
index 8722bf7e..9d559412 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatarray.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatstrings.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatstrings.php
index 77fbe8f4..0326d969 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatstrings.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatstrings.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefineclass.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefineclass.php
index e4020f89..7ec3001a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefineclass.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefineclass.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefined.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefined.php
index 453ddaf0..8e2ef38b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefined.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefined.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinemethod.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinemethod.php
index 5494ab4b..37d59526 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinemethod.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinemethod.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinesmethod.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinesmethod.php
index 7ad5d819..e39044be 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinesmethod.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinesmethod.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDup.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDup.php
index ff2a868a..52dfbd80 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDup.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDup.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuparray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuparray.php
index 60b1c956..470efcbe 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuparray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuparray.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuphash.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuphash.php
index 6badab7e..f084a0ba 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuphash.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuphash.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDupn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDupn.php
index a672809c..5dcc443f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDupn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDupn.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceExpandarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceExpandarray.php
index 91dce0be..1f0fc679 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceExpandarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceExpandarray.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php
index f6b3d613..9a622b51 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparamproxy.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparamproxy.php
index ab9eeb49..ec138cd1 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparamproxy.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparamproxy.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetclassvariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetclassvariable.php
index c7ffaf18..b21dbee3 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetclassvariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetclassvariable.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetconstant.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetconstant.php
index 42a0e91e..942e1258 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetconstant.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetconstant.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetglobal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetglobal.php
index 18e09904..839e2f56 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetglobal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetglobal.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetinstancevariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetinstancevariable.php
index 08b24536..07e32c1b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetinstancevariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetinstancevariable.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocal.php
index d9f3f31d..5a8d88af 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocal.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC0.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC0.php
index 3f9cd3eb..e40611e5 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC0.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC0.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC1.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC1.php
index e3157d95..2ae83417 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC1.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC1.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetspecial.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetspecial.php
index ef208b0f..29724987 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetspecial.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetspecial.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceIntern.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceIntern.php
index 9404a8b0..a8a7ee04 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceIntern.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceIntern.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokeblock.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokeblock.php
index e71b3a24..06d7ab50 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokeblock.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokeblock.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokebuiltin.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokebuiltin.php
index 377ec042..5ff0bb2e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokebuiltin.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokebuiltin.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokesuper.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokesuper.php
index 5ede9fb9..f42592ff 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokesuper.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokesuper.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceJump.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceJump.php
index 0b74c14b..e82e12be 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceJump.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceJump.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceLeave.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceLeave.php
index d7682bf2..ef02cf2f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceLeave.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceLeave.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarray.php
index 6ca9ef8c..ef475522 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarray.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarraykwsplat.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarraykwsplat.php
index 3c89c438..94a6e038 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarraykwsplat.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarraykwsplat.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewhash.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewhash.php
index 0d2950dc..b7c0e786 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewhash.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewhash.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewrange.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewrange.php
index 109fba8e..7f232cb5 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewrange.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewrange.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNop.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNop.php
index 33894204..feb55218 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNop.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNop.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceObjtostring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceObjtostring.php
index 0c196278..66b94f82 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceObjtostring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceObjtostring.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOnce.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOnce.php
index 10f19586..c525c1ac 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOnce.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOnce.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAnd.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAnd.php
index b0915ed4..c22be6cb 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAnd.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAnd.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAref.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAref.php
index e25a013f..47bf5051 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAref.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAref.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptArefWith.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptArefWith.php
index dae97934..88ba700a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptArefWith.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptArefWith.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAset.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAset.php
index e696740c..85b987d7 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAset.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAset.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAsetWith.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAsetWith.php
index 9106aa11..74876b05 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAsetWith.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAsetWith.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptCaseDispatch.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptCaseDispatch.php
index 1bb6cbcd..f109f06d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptCaseDispatch.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptCaseDispatch.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptDiv.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptDiv.php
index e71f51d1..c68d0081 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptDiv.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptDiv.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEmptyP.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEmptyP.php
index 73a1dff5..50fbf94a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEmptyP.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEmptyP.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEq.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEq.php
index ce72aa5b..16a79dda 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEq.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEq.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGe.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGe.php
index cf1bdf22..aa10a541 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGe.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGe.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGetconstantPath.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGetconstantPath.php
index 025045cc..760869eb 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGetconstantPath.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGetconstantPath.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGt.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGt.php
index 431b6d8f..7e73b789 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGt.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGt.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegate.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegate.php
index dbc5ccc4..681ff4d5 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegate.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegate.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegateLeave.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegateLeave.php
index 0b9c50c7..2933e723 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegateLeave.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegateLeave.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLe.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLe.php
index 9337c95f..8eb991ae 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLe.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLe.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLength.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLength.php
index c4cbac19..8e8e4fd8 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLength.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLength.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLt.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLt.php
index d2912bff..56341149 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLt.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLt.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLtlt.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLtlt.php
index 74bb7d39..ceecd8ec 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLtlt.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLtlt.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMinus.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMinus.php
index ccc4f0d1..10820bba 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMinus.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMinus.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMod.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMod.php
index db289dba..faf19b59 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMod.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMod.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMult.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMult.php
index f5976531..b8c2dd9d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMult.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMult.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNeq.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNeq.php
index 428d3a91..cc43373c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNeq.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNeq.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMax.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMax.php
index e681455e..56940704 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMax.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMax.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMin.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMin.php
index af6163b4..318a95fb 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMin.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMin.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNilP.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNilP.php
index dc6b9d1c..de307e2b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNilP.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNilP.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNot.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNot.php
index 12b040c2..34a28d2a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNot.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNot.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptOr.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptOr.php
index f4393907..40f5c9b6 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptOr.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptOr.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptPlus.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptPlus.php
index 889baa3d..fe1319f4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptPlus.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptPlus.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptRegexpmatch2.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptRegexpmatch2.php
index 5fc47753..9908212c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptRegexpmatch2.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptRegexpmatch2.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptReverse.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptReverse.php
index 26668a3c..437402fe 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptReverse.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptReverse.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSendWithoutBlock.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSendWithoutBlock.php
index 664288ca..abb37dce 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSendWithoutBlock.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSendWithoutBlock.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSize.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSize.php
index fec9f06c..084c68f4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSize.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSize.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrFreeze.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrFreeze.php
index 379250e5..c1c08018 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrFreeze.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrFreeze.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrUminus.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrUminus.php
index 98be6cf4..17a1e70b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrUminus.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrUminus.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSucc.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSucc.php
index 1a9d861a..36a5403d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSucc.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSucc.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePop.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePop.php
index 2156c49c..71829b6b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePop.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePop.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutnil.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutnil.php
index fe133f65..b903cd1d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutnil.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutnil.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobject.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobject.php
index 7b13b0cc..a82253c5 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobject.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobject.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX0.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX0.php
index 365cc0db..5f494ad0 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX0.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX0.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX1.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX1.php
index e104afda..667845c6 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX1.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX1.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutself.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutself.php
index 860fd66c..c576e907 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutself.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutself.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutspecialobject.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutspecialobject.php
index 7549bc76..fec80f57 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutspecialobject.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutspecialobject.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutstring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutstring.php
index 19fad09d..a2e1a5a7 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutstring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutstring.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSend.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSend.php
index 11de9c32..57b568b5 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSend.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSend.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetblockparam.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetblockparam.php
index c5ac3676..f8033e0b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetblockparam.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetblockparam.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetclassvariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetclassvariable.php
index 2cbeb42b..fd95811d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetclassvariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetclassvariable.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetconstant.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetconstant.php
index 854e396a..6832ce9c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetconstant.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetconstant.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetglobal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetglobal.php
index 30211f08..b8431574 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetglobal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetglobal.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetinstancevariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetinstancevariable.php
index 1148e427..b737652d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetinstancevariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetinstancevariable.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocal.php
index 3f78ae4a..040eb974 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocal.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC0.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC0.php
index ee338b7b..dc744583 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC0.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC0.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC1.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC1.php
index f2b77ff4..cac15505 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC1.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC1.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetn.php
index 310891e4..b0d27f6c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetn.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetspecial.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetspecial.php
index 7c6c8128..8faddad5 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetspecial.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetspecial.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSplatarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSplatarray.php
index 90053827..c0afc534 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSplatarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSplatarray.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSwap.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSwap.php
index 6cafc63f..340010c0 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSwap.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSwap.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceThrow.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceThrow.php
index 473f1f84..26d65073 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceThrow.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceThrow.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceTopn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceTopn.php
index 78c515b4..33183c8b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceTopn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceTopn.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceToregexp.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceToregexp.php
index 9f87bded..78b4bc2f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceToregexp.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceToregexp.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Operation/Operand.php b/src/VM/Core/Runtime/Executor/Operation/Operand.php
index dc025d7a..d3fa42e3 100644
--- a/src/VM/Core/Runtime/Executor/Operation/Operand.php
+++ b/src/VM/Core/Runtime/Executor/Operation/Operand.php
@@ -13,7 +13,7 @@
 class Operand
 {
     public function __construct(
-        public CallInfoInterface|RubyClassInterface|ID|ExecutedResult|ContextInterface $operand
+        public CallInfoInterface|ContextInterface|ExecutedResult|ID|RubyClassInterface $operand
     ) {}
 
     public function __clone()
diff --git a/src/VM/Core/Runtime/Executor/Operation/OperandHelper.php b/src/VM/Core/Runtime/Executor/Operation/OperandHelper.php
index 1812459a..cca1fcff 100644
--- a/src/VM/Core/Runtime/Executor/Operation/OperandHelper.php
+++ b/src/VM/Core/Runtime/Executor/Operation/OperandHelper.php
@@ -163,7 +163,7 @@ private function operand(): Operand
         return $operand;
     }
 
-    private function operandAsAny(string $className): CallInfoInterface|RubyClassInterface|ID|ExecutedResult|ContextInterface
+    private function operandAsAny(string $className): CallInfoInterface|ContextInterface|ExecutedResult|ID|RubyClassInterface
     {
         $operand = $this->operand();
 
@@ -248,7 +248,7 @@ private function stackAsString(): String_
         return $entity;
     }
 
-    private function stackAsStringOrNil(): String_|NilClass
+    private function stackAsStringOrNil(): NilClass|String_
     {
         $entity = $this->stackAsRubyClass();
 
@@ -353,7 +353,7 @@ private function getStack(): Operand
         return $operand;
     }
 
-    private function stackAsAny(string $className): CallInfoInterface|RubyClassInterface|ID|ExecutedResult|ContextInterface
+    private function stackAsAny(string $className): CallInfoInterface|ContextInterface|ExecutedResult|ID|RubyClassInterface
     {
         $operand = $this->getStack();
 
diff --git a/src/VM/Core/Runtime/Executor/Operation/OperationEntries.php b/src/VM/Core/Runtime/Executor/Operation/OperationEntries.php
index 99d5d7af..b628bedd 100644
--- a/src/VM/Core/Runtime/Executor/Operation/OperationEntries.php
+++ b/src/VM/Core/Runtime/Executor/Operation/OperationEntries.php
@@ -24,7 +24,7 @@ public function __toString(): string
             $result[] = ClassHelper::nameBy($item) . '<' . match ($item::class) {
                 Operation::class => sprintf(
                     '%s<0x%02x>',
-                    strtolower($item->insn->name),
+                    strtolower((string) $item->insn->name),
                     $item->insn->value
                 ),
                 Operand::class => ClassHelper::nameBy($item->operand),
diff --git a/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorEntries.php b/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorEntries.php
index 5723639f..7c09d515 100644
--- a/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorEntries.php
+++ b/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorEntries.php
@@ -28,7 +28,7 @@ public function get(mixed $index): OperationProcessorInterface
 
         $processor = parent::get($index);
         if (!$processor instanceof OperationProcessorInterface) {
-            throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not registered', strtolower($index->name), $index->value));
+            throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not registered', strtolower((string) $index->name), $index->value));
         }
 
         return $processor;
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_2/Kernel.php b/src/VM/Core/Runtime/Kernel/Ruby3_2/Kernel.php
index 35eea5fb..52dc158b 100644
--- a/src/VM/Core/Runtime/Kernel/Ruby3_2/Kernel.php
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_2/Kernel.php
@@ -1,6 +1,5 @@
 <?php
 /**
- *
  * $$$$$$$\            $$\                 $$\    $$\ $$\      $$\                                 $$$$$$$\  $$\   $$\ $$$$$$$\
  * $$  __$$\           $$ |                $$ |   $$ |$$$\    $$$ |                                $$  __$$\ $$ |  $$ |$$  __$$\
  * $$ |  $$ |$$\   $$\ $$$$$$$\  $$\   $$\ $$ |   $$ |$$$$\  $$$$ |       $$$$$$\  $$$$$$$\        $$ |  $$ |$$ |  $$ |$$ |  $$ |
@@ -11,7 +10,7 @@
  * \__|  \__| \______/ \_______/  \____$$ |    \_/    \__|     \__|       \______/ \__|  \__|      \__|      \__|  \__|\__|
  *                               $$\   $$ |
  *                               \$$$$$$  |
- *                                \______/
+ *                                \______/.
  */
 
 declare(strict_types=1);
@@ -385,6 +384,7 @@ public function instructionSequenceList(): Offsets
     public function operationProcessorEntries(): OperationProcessorEntries
     {
         static $entries;
+
         return $entries ??= new \RubyVM\VM\Core\Runtime\Kernel\Ruby3_2\InstructionSequence\OperationProcessorEntries();
     }
 }
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceProcessor.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceProcessor.php
index 5e5103b9..3eab1fdc 100644
--- a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceProcessor.php
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/InstructionSequenceProcessor.php
@@ -490,47 +490,47 @@ private function processInlineCache(int $value): ID
     private function insnOperationsOperands(): array
     {
         return [
-            "",     "\0", "LN",   "\0", "LN",   "\0", "LN",   "\0", "LN",   "\0",
-            "LN",   "\0", "NN",   "\0", "N",    "\0", "IA",   "\0", "IA",   "\0",
-            "IJ",   "\0", "IJ",   "\0", "K",    "\0", "I",    "\0", "I",    "\0",
-            "I",    "\0", "I",    "\0", "",     "\0", "",     "\0", "V",    "\0",
-            "N",    "\0", "V",    "\0", "N",    "\0", "",     "\0", "NN",   "\0",
-            "",     "\0", "N",    "\0", "N",    "\0", "V",    "\0", "V",    "\0",
-            "NN",   "\0", "",     "\0", "V",    "\0", "",     "\0", "N",    "\0",
-            "N",    "\0", "",     "\0", "",     "\0", "N",    "\0", "",     "\0",
-            "N",    "\0", "N",    "\0", "N",    "\0", "N",    "\0", "NVV",  "\0",
-            "IAV",  "\0", "N",    "\0", "LL",   "\0", "N",    "\0", "ISN",  "\0",
-            "IS",   "\0", "IS",   "\0", "CS",   "\0", "C",    "\0", "C",    "\0",
-            "VC",   "\0", "C",    "\0", "VC",   "\0", "NI",   "\0", "CS",   "\0",
-            "C",    "\0", "",     "\0", "N",    "\0", "O",    "\0", "O",    "\0",
-            "O",    "\0", "O",    "\0", "ST",   "\0", "HO",   "\0", "C",    "\0",
-            "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0",
-            "CC",   "\0", "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0",
-            "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0",
-            "VC",   "\0", "VC",   "\0", "C",    "\0", "C",    "\0", "C",    "\0",
-            "C",    "\0", "C",    "\0", "C",    "\0", "R",    "\0", "RN",   "\0",
-            "RN",   "\0", "L",    "\0", "L",    "\0", "L",    "\0", "L",    "\0",
-            "",     "\0", "",     "\0", "",     "\0", "LN",   "\0", "LN",   "\0",
-            "LN",   "\0", "LN",   "\0", "LN",   "\0", "NN",   "\0", "N",    "\0",
-            "IA",   "\0", "IA",   "\0", "IJ",   "\0", "IJ",   "\0", "K",    "\0",
-            "I",    "\0", "I",    "\0", "I",    "\0", "I",    "\0", "",     "\0",
-            "",     "\0", "V",    "\0", "N",    "\0", "V",    "\0", "N",    "\0",
-            "",     "\0", "NN",   "\0", "",     "\0", "N",    "\0", "N",    "\0",
-            "V",    "\0", "V",    "\0", "NN",   "\0", "",     "\0", "V",    "\0",
-            "",     "\0", "N",    "\0", "N",    "\0", "",     "\0", "",     "\0",
-            "N",    "\0", "",     "\0", "N",    "\0", "N",    "\0", "N",    "\0",
-            "N",    "\0", "NVV",  "\0", "IAV",  "\0", "N",    "\0", "LL",   "\0",
-            "N",    "\0", "ISN",  "\0", "IS",   "\0", "IS",   "\0", "CS",   "\0",
-            "C",    "\0", "C",    "\0", "VC",   "\0", "C",    "\0", "VC",   "\0",
-            "NI",   "\0", "CS",   "\0", "C",    "\0", "",     "\0", "N",    "\0",
-            "O",    "\0", "O",    "\0", "O",    "\0", "O",    "\0", "ST",   "\0",
-            "HO",   "\0", "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0",
-            "C",    "\0", "C",    "\0", "CC",   "\0", "C",    "\0", "C",    "\0",
-            "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0",
-            "C",    "\0", "C",    "\0", "VC",   "\0", "VC",   "\0", "C",    "\0",
-            "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0", "C",    "\0",
-            "R",    "\0", "RN",   "\0", "RN",   "\0", "L",    "\0", "L",    "\0",
-            "L",    "\0", "L",    "\0", "",     "\0", "",     "\0",
+            '',     "\0", 'LN',   "\0", 'LN',   "\0", 'LN',   "\0", 'LN',   "\0",
+            'LN',   "\0", 'NN',   "\0", 'N',    "\0", 'IA',   "\0", 'IA',   "\0",
+            'IJ',   "\0", 'IJ',   "\0", 'K',    "\0", 'I',    "\0", 'I',    "\0",
+            'I',    "\0", 'I',    "\0", '',     "\0", '',     "\0", 'V',    "\0",
+            'N',    "\0", 'V',    "\0", 'N',    "\0", '',     "\0", 'NN',   "\0",
+            '',     "\0", 'N',    "\0", 'N',    "\0", 'V',    "\0", 'V',    "\0",
+            'NN',   "\0", '',     "\0", 'V',    "\0", '',     "\0", 'N',    "\0",
+            'N',    "\0", '',     "\0", '',     "\0", 'N',    "\0", '',     "\0",
+            'N',    "\0", 'N',    "\0", 'N',    "\0", 'N',    "\0", 'NVV',  "\0",
+            'IAV',  "\0", 'N',    "\0", 'LL',   "\0", 'N',    "\0", 'ISN',  "\0",
+            'IS',   "\0", 'IS',   "\0", 'CS',   "\0", 'C',    "\0", 'C',    "\0",
+            'VC',   "\0", 'C',    "\0", 'VC',   "\0", 'NI',   "\0", 'CS',   "\0",
+            'C',    "\0", '',     "\0", 'N',    "\0", 'O',    "\0", 'O',    "\0",
+            'O',    "\0", 'O',    "\0", 'ST',   "\0", 'HO',   "\0", 'C',    "\0",
+            'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
+            'CC',   "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
+            'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
+            'VC',   "\0", 'VC',   "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
+            'C',    "\0", 'C',    "\0", 'C',    "\0", 'R',    "\0", 'RN',   "\0",
+            'RN',   "\0", 'L',    "\0", 'L',    "\0", 'L',    "\0", 'L',    "\0",
+            '',     "\0", '',     "\0", '',     "\0", 'LN',   "\0", 'LN',   "\0",
+            'LN',   "\0", 'LN',   "\0", 'LN',   "\0", 'NN',   "\0", 'N',    "\0",
+            'IA',   "\0", 'IA',   "\0", 'IJ',   "\0", 'IJ',   "\0", 'K',    "\0",
+            'I',    "\0", 'I',    "\0", 'I',    "\0", 'I',    "\0", '',     "\0",
+            '',     "\0", 'V',    "\0", 'N',    "\0", 'V',    "\0", 'N',    "\0",
+            '',     "\0", 'NN',   "\0", '',     "\0", 'N',    "\0", 'N',    "\0",
+            'V',    "\0", 'V',    "\0", 'NN',   "\0", '',     "\0", 'V',    "\0",
+            '',     "\0", 'N',    "\0", 'N',    "\0", '',     "\0", '',     "\0",
+            'N',    "\0", '',     "\0", 'N',    "\0", 'N',    "\0", 'N',    "\0",
+            'N',    "\0", 'NVV',  "\0", 'IAV',  "\0", 'N',    "\0", 'LL',   "\0",
+            'N',    "\0", 'ISN',  "\0", 'IS',   "\0", 'IS',   "\0", 'CS',   "\0",
+            'C',    "\0", 'C',    "\0", 'VC',   "\0", 'C',    "\0", 'VC',   "\0",
+            'NI',   "\0", 'CS',   "\0", 'C',    "\0", '',     "\0", 'N',    "\0",
+            'O',    "\0", 'O',    "\0", 'O',    "\0", 'O',    "\0", 'ST',   "\0",
+            'HO',   "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
+            'C',    "\0", 'C',    "\0", 'CC',   "\0", 'C',    "\0", 'C',    "\0",
+            'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
+            'C',    "\0", 'C',    "\0", 'VC',   "\0", 'VC',   "\0", 'C',    "\0",
+            'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0", 'C',    "\0",
+            'R',    "\0", 'RN',   "\0", 'RN',   "\0", 'L',    "\0", 'L',    "\0",
+            'L',    "\0", 'L',    "\0", '',     "\0", '',     "\0",
         ];
     }
 
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/OperationProcessorEntries.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/OperationProcessorEntries.php
index 11da170f..dcd2832d 100644
--- a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/OperationProcessorEntries.php
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/OperationProcessorEntries.php
@@ -68,8 +68,6 @@
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptMod;
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptMult;
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptNeq;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptNewarrayMax;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptNewarrayMin;
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptNilP;
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptNot;
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinOptOr;
@@ -169,8 +167,6 @@
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptMod;
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptMult;
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptNeq;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptNewarrayMax;
-use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptNewarrayMin;
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptNilP;
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptNot;
 use RubyVM\VM\Core\Runtime\Executor\Insn\Processor\BuiltinTraceOptOr;
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php
index 62ca9206..3cb7bd61 100644
--- a/src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/Kernel.php
@@ -1,6 +1,5 @@
 <?php
 /**
- *
  * $$$$$$$\            $$\                 $$\    $$\ $$\      $$\                                 $$$$$$$\  $$\   $$\ $$$$$$$\
  * $$  __$$\           $$ |                $$ |   $$ |$$$\    $$$ |                                $$  __$$\ $$ |  $$ |$$  __$$\
  * $$ |  $$ |$$\   $$\ $$$$$$$\  $$\   $$\ $$ |   $$ |$$$$\  $$$$ |       $$$$$$\  $$$$$$$\        $$ |  $$ |$$ |  $$ |$$ |  $$ |
@@ -11,7 +10,7 @@
  * \__|  \__| \______/ \_______/  \____$$ |    \_/    \__|     \__|       \______/ \__|  \__|      \__|      \__|  \__|\__|
  *                               $$\   $$ |
  *                               \$$$$$$  |
- *                                \______/
+ *                                \______/.
  */
 
 declare(strict_types=1);
@@ -391,6 +390,7 @@ public function instructionSequenceList(): Offsets
     public function operationProcessorEntries(): OperationProcessorEntries
     {
         static $entries;
+
         return $entries ??= new \RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\InstructionSequence\OperationProcessorEntries();
     }
 }
diff --git a/src/VM/Core/Runtime/Option.php b/src/VM/Core/Runtime/Option.php
index bcaee632..37396507 100644
--- a/src/VM/Core/Runtime/Option.php
+++ b/src/VM/Core/Runtime/Option.php
@@ -8,7 +8,6 @@
 use RubyVM\VM\Core\Runtime\Essential\MainInterface;
 use RubyVM\VM\Core\Runtime\Executor\Debugger\DebuggerInterface;
 use RubyVM\VM\Core\Runtime\Executor\Debugger\DefaultExecutorDebugger;
-use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorEntries;
 use RubyVM\VM\Stream\BinaryStreamReaderInterface;
 use RubyVM\VM\Stream\StreamHandler;
 use RubyVM\VM\Stream\StreamHandlerInterface;
diff --git a/src/VM/Core/Runtime/OptionInterface.php b/src/VM/Core/Runtime/OptionInterface.php
index 539fcb6a..67900c93 100644
--- a/src/VM/Core/Runtime/OptionInterface.php
+++ b/src/VM/Core/Runtime/OptionInterface.php
@@ -6,7 +6,6 @@
 
 use Psr\Log\LoggerInterface;
 use RubyVM\VM\Core\Runtime\Executor\Debugger\DebuggerInterface;
-use RubyVM\VM\Core\Runtime\Executor\Operation\Processor\OperationProcessorEntries;
 use RubyVM\VM\Stream\StreamHandlerInterface;
 
 interface OptionInterface
diff --git a/src/VM/Core/Runtime/Provider/ProvideExtendedMethodCall.php b/src/VM/Core/Runtime/Provider/ProvideExtendedMethodCall.php
index a4b7294b..2a27ed1c 100644
--- a/src/VM/Core/Runtime/Provider/ProvideExtendedMethodCall.php
+++ b/src/VM/Core/Runtime/Provider/ProvideExtendedMethodCall.php
@@ -22,7 +22,7 @@ trait ProvideExtendedMethodCall
     /**
      * @param (ContextInterface|RubyClassInterface)[] $arguments
      */
-    public function __call(string $name, array $arguments): ExecutedResult|RubyClassInterface|null
+    public function __call(string $name, array $arguments): null|ExecutedResult|RubyClassInterface
     {
         // @phpstan-ignore-next-line
         if ($this->context === null) {
diff --git a/src/VM/Core/Runtime/RubyVM.php b/src/VM/Core/Runtime/RubyVM.php
index c646fb11..30f9adbc 100644
--- a/src/VM/Core/Runtime/RubyVM.php
+++ b/src/VM/Core/Runtime/RubyVM.php
@@ -16,6 +16,7 @@
 class RubyVM implements RubyVMInterface
 {
     final public const DEFAULT_VERSION = RubyVersion::VERSION_3_3;
+
     protected RubyVersion $specifiedDefaultVersion = self::DEFAULT_VERSION;
 
     /**
@@ -28,12 +29,12 @@ public function __construct(public readonly Option $option)
         // Register default kernels
         $this->register(
             rubyVersion: RubyVersion::VERSION_3_3,
-            kernelClass: \RubyVM\VM\Core\Runtime\Kernel\Ruby3_3\Kernel::class,
+            kernelClass: Kernel\Ruby3_3\Kernel::class,
         );
 
         $this->register(
             rubyVersion: RubyVersion::VERSION_3_2,
-            kernelClass: \RubyVM\VM\Core\Runtime\Kernel\Ruby3_2\Kernel::class,
+            kernelClass: Kernel\Ruby3_2\Kernel::class,
         );
     }
 
@@ -117,6 +118,7 @@ public function runtime(RubyVersion $useVersion = null): Runtime
     public function setDefaultVersion(RubyVersion $rubyVersion): self
     {
         $this->specifiedDefaultVersion = $rubyVersion;
+
         return $this;
     }
 
diff --git a/src/VM/Core/Runtime/UserlandClassEntries.php b/src/VM/Core/Runtime/UserlandClassEntries.php
index 4effe8e7..1affa5b3 100644
--- a/src/VM/Core/Runtime/UserlandClassEntries.php
+++ b/src/VM/Core/Runtime/UserlandClassEntries.php
@@ -37,7 +37,7 @@ public function alias(string $name, string $to): self
         return $this;
     }
 
-    public function aliasNameBy(string $name): string|null
+    public function aliasNameBy(string $name): null|string
     {
         return $this->aliases->get($name);
     }
diff --git a/src/VM/Core/YARV/Criterion/Offset/Offset.php b/src/VM/Core/YARV/Criterion/Offset/Offset.php
index 027f7fc3..375bd0c7 100644
--- a/src/VM/Core/YARV/Criterion/Offset/Offset.php
+++ b/src/VM/Core/YARV/Criterion/Offset/Offset.php
@@ -27,7 +27,7 @@ public function increase(): Offset
      *
      * @param int|SizeOf|SizeOf[] $size
      */
-    public function align(SizeOf|array|int $size): Offset
+    public function align(array|int|SizeOf $size): Offset
     {
         if (is_array($size)) {
             return $this->align(Align::alignOf($size));
diff --git a/src/VM/Core/YARV/Criterion/Structure/AbstractStructure.php b/src/VM/Core/YARV/Criterion/Structure/AbstractStructure.php
index a5e76f83..70aeb5f9 100644
--- a/src/VM/Core/YARV/Criterion/Structure/AbstractStructure.php
+++ b/src/VM/Core/YARV/Criterion/Structure/AbstractStructure.php
@@ -38,7 +38,7 @@ public function __construct(protected readonly BinaryStreamReaderInterface $read
         }
     }
 
-    public function __get(string $name): int|float|string
+    public function __get(string $name): float|int|string
     {
         return $this->structureProperties[$name];
     }
diff --git a/src/VM/Core/YARV/Criterion/Structure/StructureInterface.php b/src/VM/Core/YARV/Criterion/Structure/StructureInterface.php
index 7bc33b35..8abdd405 100644
--- a/src/VM/Core/YARV/Criterion/Structure/StructureInterface.php
+++ b/src/VM/Core/YARV/Criterion/Structure/StructureInterface.php
@@ -13,5 +13,5 @@ interface StructureInterface
      */
     public static function structure(): array;
 
-    public function __get(string $name): int|string|float;
+    public function __get(string $name): float|int|string;
 }
diff --git a/src/VM/Core/YARV/Essential/Symbol/RangeSymbol.php b/src/VM/Core/YARV/Essential/Symbol/RangeSymbol.php
index 7c5255cf..5b387c0e 100644
--- a/src/VM/Core/YARV/Essential/Symbol/RangeSymbol.php
+++ b/src/VM/Core/YARV/Essential/Symbol/RangeSymbol.php
@@ -19,8 +19,8 @@ class RangeSymbol implements SymbolInterface, \ArrayAccess, \Countable, \Stringa
     private int $behindPos = 0;
 
     public function __construct(
-        private readonly NumberSymbol|NilSymbol $begin,
-        private readonly NumberSymbol|NilSymbol $end,
+        private readonly NilSymbol|NumberSymbol $begin,
+        private readonly NilSymbol|NumberSymbol $end,
         private readonly bool $excludeEnd,
     ) {
         $this->pointer = $this->begin->valueOf() ?? 0;
diff --git a/src/VM/Core/YARV/Essential/Symbol/RegexpSymbol.php b/src/VM/Core/YARV/Essential/Symbol/RegexpSymbol.php
index 2507969d..239e69b7 100644
--- a/src/VM/Core/YARV/Essential/Symbol/RegexpSymbol.php
+++ b/src/VM/Core/YARV/Essential/Symbol/RegexpSymbol.php
@@ -8,7 +8,7 @@ class RegexpSymbol implements SymbolInterface, \Stringable
 {
     public function __construct(
         private readonly StringSymbol $source,
-        private readonly int|null $option,
+        private readonly null|int $option,
     ) {}
 
     public function valueOf(): StringSymbol
@@ -21,7 +21,7 @@ public function __toString(): string
         return (string) $this->source;
     }
 
-    public function option(): int|null
+    public function option(): null|int
     {
         return $this->option;
     }
diff --git a/src/VM/Stream/BinaryStreamReader.php b/src/VM/Stream/BinaryStreamReader.php
index 55762fde..168774e7 100644
--- a/src/VM/Stream/BinaryStreamReader.php
+++ b/src/VM/Stream/BinaryStreamReader.php
@@ -50,7 +50,7 @@ public function readAsLong(): int
         );
     }
 
-    public function readAsLongLong(): int|float
+    public function readAsLongLong(): float|int
     {
         $value = $this->readAsUnsignedLongLong();
 
@@ -148,7 +148,7 @@ public function read(int $bytes): string
         return $this->streamHandler->read($bytes);
     }
 
-    private function readWithEndian(string $littleEndian, string $bigEndian, SizeOf $bytes): int|float
+    private function readWithEndian(string $littleEndian, string $bigEndian, SizeOf $bytes): float|int
     {
         $read = unpack(
             Endian::LITTLE_ENDIAN === $this->endian
diff --git a/src/VM/Stream/BinaryStreamReaderInterface.php b/src/VM/Stream/BinaryStreamReaderInterface.php
index 69eecf78..9ca572c0 100644
--- a/src/VM/Stream/BinaryStreamReaderInterface.php
+++ b/src/VM/Stream/BinaryStreamReaderInterface.php
@@ -18,7 +18,7 @@ public function readAsInt(): int;
 
     public function readAsLong(): int;
 
-    public function readAsLongLong(): int|float;
+    public function readAsLongLong(): float|int;
 
     public function readAsDouble(): float;
 
@@ -30,7 +30,7 @@ public function readAsUnsignedInt(): int;
 
     public function readAsUnsignedLong(): int;
 
-    public function readAsUnsignedLongLong(): int|float;
+    public function readAsUnsignedLongLong(): float|int;
 
     public function readAsUnsignedShort(): int;
 
diff --git a/tests/Helper/TestApplication.php b/tests/Helper/TestApplication.php
index d9749a84..286503e8 100644
--- a/tests/Helper/TestApplication.php
+++ b/tests/Helper/TestApplication.php
@@ -16,7 +16,9 @@
 class TestApplication extends TestCase
 {
     protected ?int $major = null;
+
     protected ?int $minor = null;
+
     protected ?int $patch = null;
 
     protected function createRubyVMFromCode(string $code, string $extraData = '', string $binaryPath = 'ruby'): RubyVMManager
diff --git a/tests/Internal/DebugFormatTest.php b/tests/Internal/DebugFormatTest.php
index 280404c8..32b72cff 100644
--- a/tests/Internal/DebugFormatTest.php
+++ b/tests/Internal/DebugFormatTest.php
@@ -34,7 +34,7 @@ public function __toString(): string
         };
 
         $class[] = new Operation(match ("{$this->major}.{$this->minor}") {
-            "3.3" => Ruby3_3_Insn::SEND,
+            '3.3' => Ruby3_3_Insn::SEND,
             default => Ruby3_2_Insn::SEND,
         });
         $class[] = new Operand(Integer_::createBy(0));
diff --git a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/IntegerTest.php b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/IntegerTest.php
index 61b2c683..ce86e358 100644
--- a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/IntegerTest.php
+++ b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/IntegerTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\Call\BasicObject\Kernel\Object_\Enumerable;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/StringTest.php b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/StringTest.php
index 78c43f9b..c209ed2b 100644
--- a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/StringTest.php
+++ b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Comparable/StringTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\Call\BasicObject\Kernel\Object_\Enumerable;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/ArrayTest.php b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/ArrayTest.php
index d6633f74..7507ff0a 100644
--- a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/ArrayTest.php
+++ b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/ArrayTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\Call\BasicObject\Kernel\Object_\Enumerable;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/RangeTest.php b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/RangeTest.php
index 81a141e0..1a15836b 100644
--- a/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/RangeTest.php
+++ b/tests/Version/RubyVM/Call/BasicObject/Kernel/Object_/Enumerable/RangeTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\Call\BasicObject\Kernel\Object_\Enumerable;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/Call/Logic/Complex/FibonacciTest.php b/tests/Version/RubyVM/Call/Logic/Complex/FibonacciTest.php
index 023f03a6..0ca0be65 100644
--- a/tests/Version/RubyVM/Call/Logic/Complex/FibonacciTest.php
+++ b/tests/Version/RubyVM/Call/Logic/Complex/FibonacciTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\Call\Complex;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/Call/Logic/Complex/FizzBuzzTest.php b/tests/Version/RubyVM/Call/Logic/Complex/FizzBuzzTest.php
index 6ce5c1a2..432d8be1 100644
--- a/tests/Version/RubyVM/Call/Logic/Complex/FizzBuzzTest.php
+++ b/tests/Version/RubyVM/Call/Logic/Complex/FizzBuzzTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\Call\Complex;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/Call/Logic/Complex/QuicksortTest.php b/tests/Version/RubyVM/Call/Logic/Complex/QuicksortTest.php
index 237f2cdc..87012074 100644
--- a/tests/Version/RubyVM/Call/Logic/Complex/QuicksortTest.php
+++ b/tests/Version/RubyVM/Call/Logic/Complex/QuicksortTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\Call\Complex;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/Call/Method/ExitTest.php b/tests/Version/RubyVM/Call/Method/ExitTest.php
index 4f4bedd5..839497b5 100644
--- a/tests/Version/RubyVM/Call/Method/ExitTest.php
+++ b/tests/Version/RubyVM/Call/Method/ExitTest.php
@@ -4,7 +4,6 @@
 
 namespace Tests\RubyVM\Version\RubyVM\Call\Method;
 
-use RubyVM\VM\Core\YARV\RubyVersion;
 use RubyVM\VM\Exception\ExitException;
 use Tests\RubyVM\Helper\TestApplication;
 
diff --git a/tests/Version/RubyVM/Call/Method/InspectionTest.php b/tests/Version/RubyVM/Call/Method/InspectionTest.php
index f6853ccd..268f0c94 100644
--- a/tests/Version/RubyVM/Call/Method/InspectionTest.php
+++ b/tests/Version/RubyVM/Call/Method/InspectionTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\Call\Method;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/Call/Method/MethodTest.php b/tests/Version/RubyVM/Call/Method/MethodTest.php
index f44fd5db..93c72f2f 100644
--- a/tests/Version/RubyVM/Call/Method/MethodTest.php
+++ b/tests/Version/RubyVM/Call/Method/MethodTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\Call\Method;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/Call/Method/NilTest.php b/tests/Version/RubyVM/Call/Method/NilTest.php
index 97ebe5c4..dc0f9468 100644
--- a/tests/Version/RubyVM/Call/Method/NilTest.php
+++ b/tests/Version/RubyVM/Call/Method/NilTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\Call\Method;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/Call/Method/PTest.php b/tests/Version/RubyVM/Call/Method/PTest.php
index 53e99b8a..b2328ed5 100644
--- a/tests/Version/RubyVM/Call/Method/PTest.php
+++ b/tests/Version/RubyVM/Call/Method/PTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\Call\Method;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/Call/Method/ProcTest.php b/tests/Version/RubyVM/Call/Method/ProcTest.php
index d1f61c39..728fcb01 100644
--- a/tests/Version/RubyVM/Call/Method/ProcTest.php
+++ b/tests/Version/RubyVM/Call/Method/ProcTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\Call\Method;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/Call/Method/ToIntTest.php b/tests/Version/RubyVM/Call/Method/ToIntTest.php
index 65d780c1..27d6cce3 100644
--- a/tests/Version/RubyVM/Call/Method/ToIntTest.php
+++ b/tests/Version/RubyVM/Call/Method/ToIntTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\Call\Method;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/Call/Method/ToStringTest.php b/tests/Version/RubyVM/Call/Method/ToStringTest.php
index 7adf75d4..1a834ed9 100644
--- a/tests/Version/RubyVM/Call/Method/ToStringTest.php
+++ b/tests/Version/RubyVM/Call/Method/ToStringTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\Call\Method;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/Call/PHP/CallRubyMethodsTest.php b/tests/Version/RubyVM/Call/PHP/CallRubyMethodsTest.php
index 8d4d0ae4..210298f3 100644
--- a/tests/Version/RubyVM/Call/PHP/CallRubyMethodsTest.php
+++ b/tests/Version/RubyVM/Call/PHP/CallRubyMethodsTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\Call\PHP;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/ArithmeticTest.php b/tests/Version/RubyVM/GenericSyntax/ArithmeticTest.php
index c433ca5b..90e8f5f1 100644
--- a/tests/Version/RubyVM/GenericSyntax/ArithmeticTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/ArithmeticTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/BlockTest.php b/tests/Version/RubyVM/GenericSyntax/BlockTest.php
index bd8a8ee6..97076904 100644
--- a/tests/Version/RubyVM/GenericSyntax/BlockTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/BlockTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/BooleanTest.php b/tests/Version/RubyVM/GenericSyntax/BooleanTest.php
index 18e53485..7846d962 100644
--- a/tests/Version/RubyVM/GenericSyntax/BooleanTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/BooleanTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/CaseWhenTest.php b/tests/Version/RubyVM/GenericSyntax/CaseWhenTest.php
index 9ecaa850..57b1b97f 100644
--- a/tests/Version/RubyVM/GenericSyntax/CaseWhenTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/CaseWhenTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/Class/DefineClassTest.php b/tests/Version/RubyVM/GenericSyntax/Class/DefineClassTest.php
index 3c1c08ba..b406d6db 100644
--- a/tests/Version/RubyVM/GenericSyntax/Class/DefineClassTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/Class/DefineClassTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax\Class;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/Class/DefineMethodInClassTest.php b/tests/Version/RubyVM/GenericSyntax/Class/DefineMethodInClassTest.php
index 3aeb6496..7da0e1e9 100644
--- a/tests/Version/RubyVM/GenericSyntax/Class/DefineMethodInClassTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/Class/DefineMethodInClassTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax\Class;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/Class/DefineStaticMethodTest.php b/tests/Version/RubyVM/GenericSyntax/Class/DefineStaticMethodTest.php
index 1c0390db..ebb33355 100644
--- a/tests/Version/RubyVM/GenericSyntax/Class/DefineStaticMethodTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/Class/DefineStaticMethodTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax\Class;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/Class/ExtendedClassTest.php b/tests/Version/RubyVM/GenericSyntax/Class/ExtendedClassTest.php
index e091e0a2..3a6991ec 100644
--- a/tests/Version/RubyVM/GenericSyntax/Class/ExtendedClassTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/Class/ExtendedClassTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax\Class;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/Class/InstanceVariableTest.php b/tests/Version/RubyVM/GenericSyntax/Class/InstanceVariableTest.php
index 1660dcba..c5ebe87f 100644
--- a/tests/Version/RubyVM/GenericSyntax/Class/InstanceVariableTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/Class/InstanceVariableTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax\Class;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/ComparableTest.php b/tests/Version/RubyVM/GenericSyntax/ComparableTest.php
index 53c021aa..86eead04 100644
--- a/tests/Version/RubyVM/GenericSyntax/ComparableTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/ComparableTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/ConcatTest.php b/tests/Version/RubyVM/GenericSyntax/ConcatTest.php
index 9df9f86b..f2098366 100644
--- a/tests/Version/RubyVM/GenericSyntax/ConcatTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/ConcatTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/DefinedTest.php b/tests/Version/RubyVM/GenericSyntax/DefinedTest.php
index 99576c84..7547f9e8 100644
--- a/tests/Version/RubyVM/GenericSyntax/DefinedTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/DefinedTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/GlobalVariableTest.php b/tests/Version/RubyVM/GenericSyntax/GlobalVariableTest.php
index acdce1c7..956f01a0 100644
--- a/tests/Version/RubyVM/GenericSyntax/GlobalVariableTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/GlobalVariableTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/HashTest.php b/tests/Version/RubyVM/GenericSyntax/HashTest.php
index 4c869f88..0ebdfa4d 100644
--- a/tests/Version/RubyVM/GenericSyntax/HashTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/HashTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/KeywordArgumentsTest.php b/tests/Version/RubyVM/GenericSyntax/KeywordArgumentsTest.php
index da2b0446..74ae5b23 100644
--- a/tests/Version/RubyVM/GenericSyntax/KeywordArgumentsTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/KeywordArgumentsTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/LocalVariableTest.php b/tests/Version/RubyVM/GenericSyntax/LocalVariableTest.php
index 5fbb94d7..8a1e191e 100644
--- a/tests/Version/RubyVM/GenericSyntax/LocalVariableTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/LocalVariableTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/Method/BlockTest.php b/tests/Version/RubyVM/GenericSyntax/Method/BlockTest.php
index dc73f88c..f4efad7d 100644
--- a/tests/Version/RubyVM/GenericSyntax/Method/BlockTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/Method/BlockTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax\Method;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/Method/DefineMethodTest.php b/tests/Version/RubyVM/GenericSyntax/Method/DefineMethodTest.php
index 5c84f398..eca95825 100644
--- a/tests/Version/RubyVM/GenericSyntax/Method/DefineMethodTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/Method/DefineMethodTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax\Method;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/NegativeValueTest.php b/tests/Version/RubyVM/GenericSyntax/NegativeValueTest.php
index 615d0bed..645a6d27 100644
--- a/tests/Version/RubyVM/GenericSyntax/NegativeValueTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/NegativeValueTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/RaiseTest.php b/tests/Version/RubyVM/GenericSyntax/RaiseTest.php
index 9425a209..09533300 100644
--- a/tests/Version/RubyVM/GenericSyntax/RaiseTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/RaiseTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use RubyVM\VM\Exception\Raise;
 use Tests\RubyVM\Helper\TestApplication;
 
diff --git a/tests/Version/RubyVM/GenericSyntax/RegexpTest.php b/tests/Version/RubyVM/GenericSyntax/RegexpTest.php
index 93746a5a..67324879 100644
--- a/tests/Version/RubyVM/GenericSyntax/RegexpTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/RegexpTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/RescueTest.php b/tests/Version/RubyVM/GenericSyntax/RescueTest.php
index 72b98105..8e0832c5 100644
--- a/tests/Version/RubyVM/GenericSyntax/RescueTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/RescueTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/SymbolTest.php b/tests/Version/RubyVM/GenericSyntax/SymbolTest.php
index 8f459ef5..b16680b5 100644
--- a/tests/Version/RubyVM/GenericSyntax/SymbolTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/SymbolTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/GenericSyntax/VariadicTest.php b/tests/Version/RubyVM/GenericSyntax/VariadicTest.php
index 6c081ffd..984ee7c9 100644
--- a/tests/Version/RubyVM/GenericSyntax/VariadicTest.php
+++ b/tests/Version/RubyVM/GenericSyntax/VariadicTest.php
@@ -5,7 +5,6 @@
 namespace Tests\RubyVM\Version\RubyVM\GenericSyntax;
 
 use RubyVM\VM\Core\Runtime\Executor\ExecutedStatus;
-use RubyVM\VM\Core\YARV\RubyVersion;
 use Tests\RubyVM\Helper\TestApplication;
 
 /**
diff --git a/tests/Version/RubyVM/YARB/YARBStructureTest.php b/tests/Version/RubyVM/YARB/YARBStructureTest.php
index b63a2d9f..34303f39 100644
--- a/tests/Version/RubyVM/YARB/YARBStructureTest.php
+++ b/tests/Version/RubyVM/YARB/YARBStructureTest.php
@@ -24,7 +24,7 @@ public function testHeader(): void
         $this->assertSame("{$this->major}.{$this->minor}", $rubyVMManager->rubyVM->runtime()->rubyVersion());
 
         // TODO: Fix to be flexible when using any ruby version
-        if ("{$this->major}.{$this->minor}" === "3.3") {
+        if ("{$this->major}.{$this->minor}" === '3.3') {
             $this->assertSame('unknown-unknown', $rubyVMManager->rubyVM->runtime()->rubyPlatform());
         } elseif ($this->isCI()) {
             $this->assertSame('x86_64-linux', $rubyVMManager->rubyVM->runtime()->rubyPlatform());

From bfe275ee897d9627114e03b0c46b5612a0ed6f3b Mon Sep 17 00:00:00 2001
From: m3m0r7 <memory.style.serv@gmail.com>
Date: Wed, 27 Dec 2023 01:04:35 +0900
Subject: [PATCH 10/11] Fix problems

---
 .../Runtime/Executor/Debugger/DebugFormat.php |  2 +-
 .../Debugger/DefaultExecutorDebugger.php      |  4 ++--
 .../Executor/Debugger/StepByStepDebugger.php  |  4 ++--
 src/VM/Core/Runtime/Executor/Executor.php     | 22 +++++++++----------
 .../Runtime/Executor/Insn/InsnInterface.php   |  4 ++++
 .../Insn/Processor/BuiltinAdjuststack.php     |  2 +-
 .../Insn/Processor/BuiltinAnytostring.php     |  2 +-
 .../Insn/Processor/BuiltinBranchnil.php       |  2 +-
 .../Insn/Processor/BuiltinCheckkeyword.php    |  2 +-
 .../Insn/Processor/BuiltinCheckmatch.php      |  2 +-
 .../Insn/Processor/BuiltinChecktype.php       |  2 +-
 .../Insn/Processor/BuiltinConcatstrings.php   |  2 +-
 .../Insn/Processor/BuiltinDefinesmethod.php   |  2 +-
 .../Insn/Processor/BuiltinDuphash.php         |  2 +-
 .../Executor/Insn/Processor/BuiltinDupn.php   |  2 +-
 .../Insn/Processor/BuiltinExpandarray.php     |  2 +-
 .../Processor/BuiltinGetclassvariable.php     |  2 +-
 .../Insn/Processor/BuiltinGetconstant.php     |  2 +-
 .../Insn/Processor/BuiltinGetspecial.php      |  2 +-
 .../Executor/Insn/Processor/BuiltinIntern.php |  2 +-
 .../Insn/Processor/BuiltinInvokebuiltin.php   |  2 +-
 .../Insn/Processor/BuiltinInvokesuper.php     |  2 +-
 .../Insn/Processor/BuiltinNewarraykwsplat.php |  2 +-
 .../Insn/Processor/BuiltinObjtostring.php     |  2 +-
 .../Executor/Insn/Processor/BuiltinOnce.php   |  2 +-
 .../Insn/Processor/BuiltinOptArefWith.php     |  2 +-
 .../Insn/Processor/BuiltinOptAset.php         |  2 +-
 .../Insn/Processor/BuiltinOptAsetWith.php     |  2 +-
 .../BuiltinOptInvokebuiltinDelegate.php       |  2 +-
 .../BuiltinOptInvokebuiltinDelegateLeave.php  |  2 +-
 .../Insn/Processor/BuiltinOptLength.php       |  2 +-
 .../Executor/Insn/Processor/BuiltinOptNeq.php |  2 +-
 .../Insn/Processor/BuiltinOptNewarrayMax.php  |  2 +-
 .../Insn/Processor/BuiltinOptNewarrayMin.php  |  2 +-
 .../Executor/Insn/Processor/BuiltinOptNot.php |  2 +-
 .../Insn/Processor/BuiltinOptReverse.php      |  2 +-
 .../Insn/Processor/BuiltinOptSize.php         |  2 +-
 .../Insn/Processor/BuiltinOptStrFreeze.php    |  2 +-
 .../Insn/Processor/BuiltinOptStrUminus.php    |  2 +-
 .../Insn/Processor/BuiltinOptSucc.php         |  2 +-
 .../Insn/Processor/BuiltinSetblockparam.php   |  2 +-
 .../Processor/BuiltinSetclassvariable.php     |  2 +-
 .../Insn/Processor/BuiltinSetconstant.php     |  2 +-
 .../Executor/Insn/Processor/BuiltinSetn.php   |  2 +-
 .../Insn/Processor/BuiltinSetspecial.php      |  2 +-
 .../Executor/Insn/Processor/BuiltinSwap.php   |  2 +-
 .../Executor/Insn/Processor/BuiltinThrow.php  |  2 +-
 .../Insn/Processor/BuiltinToregexp.php        |  2 +-
 .../Processor/BuiltinTraceAdjuststack.php     |  2 +-
 .../Processor/BuiltinTraceAnytostring.php     |  2 +-
 .../Insn/Processor/BuiltinTraceBranchif.php   |  2 +-
 .../Insn/Processor/BuiltinTraceBranchnil.php  |  2 +-
 .../Processor/BuiltinTraceBranchunless.php    |  2 +-
 .../Processor/BuiltinTraceCheckkeyword.php    |  2 +-
 .../Insn/Processor/BuiltinTraceCheckmatch.php |  2 +-
 .../Insn/Processor/BuiltinTraceChecktype.php  |  2 +-
 .../Processor/BuiltinTraceConcatarray.php     |  2 +-
 .../Processor/BuiltinTraceConcatstrings.php   |  2 +-
 .../Processor/BuiltinTraceDefineclass.php     |  2 +-
 .../Insn/Processor/BuiltinTraceDefined.php    |  2 +-
 .../Processor/BuiltinTraceDefinemethod.php    |  2 +-
 .../Processor/BuiltinTraceDefinesmethod.php   |  2 +-
 .../Insn/Processor/BuiltinTraceDup.php        |  2 +-
 .../Insn/Processor/BuiltinTraceDuparray.php   |  2 +-
 .../Insn/Processor/BuiltinTraceDuphash.php    |  2 +-
 .../Insn/Processor/BuiltinTraceDupn.php       |  2 +-
 .../Processor/BuiltinTraceExpandarray.php     |  2 +-
 .../Processor/BuiltinTraceGetblockparam.php   |  2 +-
 .../BuiltinTraceGetblockparamproxy.php        |  2 +-
 .../BuiltinTraceGetclassvariable.php          |  2 +-
 .../Processor/BuiltinTraceGetconstant.php     |  2 +-
 .../Insn/Processor/BuiltinTraceGetglobal.php  |  2 +-
 .../BuiltinTraceGetinstancevariable.php       |  2 +-
 .../Insn/Processor/BuiltinTraceGetlocal.php   |  2 +-
 .../Processor/BuiltinTraceGetlocalWC0.php     |  2 +-
 .../Processor/BuiltinTraceGetlocalWC1.php     |  2 +-
 .../Insn/Processor/BuiltinTraceGetspecial.php |  2 +-
 .../Insn/Processor/BuiltinTraceIntern.php     |  2 +-
 .../Processor/BuiltinTraceInvokeblock.php     |  2 +-
 .../Processor/BuiltinTraceInvokebuiltin.php   |  2 +-
 .../Processor/BuiltinTraceInvokesuper.php     |  2 +-
 .../Insn/Processor/BuiltinTraceJump.php       |  2 +-
 .../Insn/Processor/BuiltinTraceLeave.php      |  2 +-
 .../Insn/Processor/BuiltinTraceNewarray.php   |  2 +-
 .../Processor/BuiltinTraceNewarraykwsplat.php |  2 +-
 .../Insn/Processor/BuiltinTraceNewhash.php    |  2 +-
 .../Insn/Processor/BuiltinTraceNewrange.php   |  2 +-
 .../Insn/Processor/BuiltinTraceNop.php        |  2 +-
 .../Processor/BuiltinTraceObjtostring.php     |  2 +-
 .../Insn/Processor/BuiltinTraceOnce.php       |  2 +-
 .../Insn/Processor/BuiltinTraceOptAnd.php     |  2 +-
 .../Insn/Processor/BuiltinTraceOptAref.php    |  2 +-
 .../Processor/BuiltinTraceOptArefWith.php     |  2 +-
 .../Insn/Processor/BuiltinTraceOptAset.php    |  2 +-
 .../Processor/BuiltinTraceOptAsetWith.php     |  2 +-
 .../Processor/BuiltinTraceOptCaseDispatch.php |  2 +-
 .../Insn/Processor/BuiltinTraceOptDiv.php     |  2 +-
 .../Insn/Processor/BuiltinTraceOptEmptyP.php  |  2 +-
 .../Insn/Processor/BuiltinTraceOptEq.php      |  2 +-
 .../Insn/Processor/BuiltinTraceOptGe.php      |  2 +-
 .../BuiltinTraceOptGetconstantPath.php        |  2 +-
 .../Insn/Processor/BuiltinTraceOptGt.php      |  2 +-
 .../BuiltinTraceOptInvokebuiltinDelegate.php  |  2 +-
 ...ltinTraceOptInvokebuiltinDelegateLeave.php |  2 +-
 .../Insn/Processor/BuiltinTraceOptLe.php      |  2 +-
 .../Insn/Processor/BuiltinTraceOptLength.php  |  2 +-
 .../Insn/Processor/BuiltinTraceOptLt.php      |  2 +-
 .../Insn/Processor/BuiltinTraceOptLtlt.php    |  2 +-
 .../Insn/Processor/BuiltinTraceOptMinus.php   |  2 +-
 .../Insn/Processor/BuiltinTraceOptMod.php     |  2 +-
 .../Insn/Processor/BuiltinTraceOptMult.php    |  2 +-
 .../Insn/Processor/BuiltinTraceOptNeq.php     |  2 +-
 .../Processor/BuiltinTraceOptNewarrayMax.php  |  2 +-
 .../Processor/BuiltinTraceOptNewarrayMin.php  |  2 +-
 .../Insn/Processor/BuiltinTraceOptNilP.php    |  2 +-
 .../Insn/Processor/BuiltinTraceOptNot.php     |  2 +-
 .../Insn/Processor/BuiltinTraceOptOr.php      |  2 +-
 .../Insn/Processor/BuiltinTraceOptPlus.php    |  2 +-
 .../Processor/BuiltinTraceOptRegexpmatch2.php |  2 +-
 .../Insn/Processor/BuiltinTraceOptReverse.php |  2 +-
 .../BuiltinTraceOptSendWithoutBlock.php       |  2 +-
 .../Insn/Processor/BuiltinTraceOptSize.php    |  2 +-
 .../Processor/BuiltinTraceOptStrFreeze.php    |  2 +-
 .../Processor/BuiltinTraceOptStrUminus.php    |  2 +-
 .../Insn/Processor/BuiltinTraceOptSucc.php    |  2 +-
 .../Insn/Processor/BuiltinTracePop.php        |  2 +-
 .../Insn/Processor/BuiltinTracePutnil.php     |  2 +-
 .../Insn/Processor/BuiltinTracePutobject.php  |  2 +-
 .../BuiltinTracePutobjectINT2FIX0.php         |  2 +-
 .../BuiltinTracePutobjectINT2FIX1.php         |  2 +-
 .../Insn/Processor/BuiltinTracePutself.php    |  2 +-
 .../BuiltinTracePutspecialobject.php          |  2 +-
 .../Insn/Processor/BuiltinTracePutstring.php  |  2 +-
 .../Insn/Processor/BuiltinTraceSend.php       |  2 +-
 .../Processor/BuiltinTraceSetblockparam.php   |  2 +-
 .../BuiltinTraceSetclassvariable.php          |  2 +-
 .../Processor/BuiltinTraceSetconstant.php     |  2 +-
 .../Insn/Processor/BuiltinTraceSetglobal.php  |  2 +-
 .../BuiltinTraceSetinstancevariable.php       |  2 +-
 .../Insn/Processor/BuiltinTraceSetlocal.php   |  2 +-
 .../Processor/BuiltinTraceSetlocalWC0.php     |  2 +-
 .../Processor/BuiltinTraceSetlocalWC1.php     |  2 +-
 .../Insn/Processor/BuiltinTraceSetn.php       |  2 +-
 .../Insn/Processor/BuiltinTraceSetspecial.php |  2 +-
 .../Insn/Processor/BuiltinTraceSplatarray.php |  2 +-
 .../Insn/Processor/BuiltinTraceSwap.php       |  2 +-
 .../Insn/Processor/BuiltinTraceThrow.php      |  2 +-
 .../Insn/Processor/BuiltinTraceTopn.php       |  2 +-
 .../Insn/Processor/BuiltinTraceToregexp.php   |  2 +-
 .../Executor/Operation/OperationEntries.php   |  4 ++--
 .../Runtime/Executor/OperatorCalculatable.php |  4 ++--
 src/VM/Core/Runtime/Executor/Validatable.php  |  2 +-
 .../Ruby3_2/InstructionSequence/Insn.php      | 10 +++++++++
 .../Ruby3_3/InstructionSequence/Insn.php      | 10 +++++++++
 154 files changed, 189 insertions(+), 165 deletions(-)

diff --git a/src/VM/Core/Runtime/Executor/Debugger/DebugFormat.php b/src/VM/Core/Runtime/Executor/Debugger/DebugFormat.php
index cf941dd4..8cee23a5 100644
--- a/src/VM/Core/Runtime/Executor/Debugger/DebugFormat.php
+++ b/src/VM/Core/Runtime/Executor/Debugger/DebugFormat.php
@@ -28,7 +28,7 @@ private static function getEntriesAsString(array $entries): string
             if ($item instanceof RubyClassInterface) {
                 $string .= "({$item})";
             } elseif ($item instanceof Operation) {
-                $string .= "({$item->insn->name})";
+                $string .= "({$item->insn->name()})";
             } elseif ($item instanceof Operand && $item->operand instanceof RubyClassInterface) {
                 $string = ClassHelper::nameBy($item->operand);
 
diff --git a/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php b/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php
index 66e8c18e..5f7c314f 100644
--- a/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php
+++ b/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php
@@ -96,8 +96,8 @@ public function showExecutedOperations(): void
                 implode(' -> ', $context->traces()),
                 sprintf(
                     '[0x%02x] %s %s',
-                    $insn->value,
-                    strtolower((string) $insn->name),
+                    $insn->value(),
+                    strtolower((string) $insn->name()),
                     $insnDetails ? "({$insnDetails})" : '',
                 ),
                 (string) $context->vmStack(),
diff --git a/src/VM/Core/Runtime/Executor/Debugger/StepByStepDebugger.php b/src/VM/Core/Runtime/Executor/Debugger/StepByStepDebugger.php
index b31cc71e..d6dbc4e1 100644
--- a/src/VM/Core/Runtime/Executor/Debugger/StepByStepDebugger.php
+++ b/src/VM/Core/Runtime/Executor/Debugger/StepByStepDebugger.php
@@ -15,8 +15,8 @@ private function processBreakPoint(InsnInterface $insn, ContextInterface $prevCo
 
         printf(
             "Current INSN: %s(0x%02x)\n",
-            strtolower((string) $insn->name),
-            $insn->value,
+            strtolower($insn->name()),
+            $insn->value(),
         );
         printf(
             "Previous Stacks: %s#%d\n",
diff --git a/src/VM/Core/Runtime/Executor/Executor.php b/src/VM/Core/Runtime/Executor/Executor.php
index 18d45264..15502715 100644
--- a/src/VM/Core/Runtime/Executor/Executor.php
+++ b/src/VM/Core/Runtime/Executor/Executor.php
@@ -191,8 +191,8 @@ private function _execute(ContextInterface|RubyClassInterface ...$arguments): Ex
             $this->option->logger()->info(
                 sprintf(
                     'Start to process an INSN `%s` (0x%02x) (ProgramCounter: %d)',
-                    strtolower((string) $operator->insn->name),
-                    $operator->insn->value,
+                    strtolower($operator->insn->name()),
+                    $operator->insn->value(),
                     $this->context->programCounter()->pos(),
                 ),
             );
@@ -205,8 +205,8 @@ private function _execute(ContextInterface|RubyClassInterface ...$arguments): Ex
             $this->option->logger()->info(
                 sprintf(
                     'Start to prepare an INSN `%s` (0x%02x) (ProgramCounter: %d)',
-                    strtolower((string) $operator->insn->name),
-                    $operator->insn->value,
+                    strtolower($operator->insn->name()),
+                    $operator->insn->value(),
                     $this->context->programCounter()->pos(),
                 ),
             );
@@ -222,8 +222,8 @@ private function _execute(ContextInterface|RubyClassInterface ...$arguments): Ex
             $this->option->logger()->info(
                 sprintf(
                     'Start to process a before method an INSN `%s` (0x%02x) (ProgramCounter: %d)',
-                    strtolower((string) $operator->insn->name),
-                    $operator->insn->value,
+                    strtolower($operator->insn->name()),
+                    $operator->insn->value(),
                     $this->context->programCounter()->pos(),
                 ),
             );
@@ -233,8 +233,8 @@ private function _execute(ContextInterface|RubyClassInterface ...$arguments): Ex
             $this->option->logger()->info(
                 sprintf(
                     'Start to process a main routine method an INSN `%s` (0x%02x) (ProgramCounter: %d)',
-                    strtolower((string) $operator->insn->name),
-                    $operator->insn->value,
+                    strtolower($operator->insn->name()),
+                    $operator->insn->value(),
                     $this->context->programCounter()->pos(),
                 ),
             );
@@ -252,8 +252,8 @@ private function _execute(ContextInterface|RubyClassInterface ...$arguments): Ex
             $this->option->logger()->info(
                 sprintf(
                     'Start to process a post method an INSN `%s` (0x%02x) (ProgramCounter: %d)',
-                    strtolower((string) $operator->insn->name),
-                    $operator->insn->value,
+                    strtolower($operator->insn->name()),
+                    $operator->insn->value(),
                     $this->context->programCounter()->pos(),
                 ),
             );
@@ -282,7 +282,7 @@ private function _execute(ContextInterface|RubyClassInterface ...$arguments): Ex
                     ? ExecutorFailedException::class
                     : ExecutorUnknownException::class;
 
-                throw new $throwClass(sprintf('The `%s` (opcode: 0x%02x) processor returns %s (%d) status code', $operator->insn->name, $operator->insn->value, $status->name, $status->value));
+                throw new $throwClass(sprintf('The `%s` (opcode: 0x%02x) processor returns %s (%d) status code', $operator->insn->name(), $operator->insn->value(), $status->name, $status->value));
             }
         }
 
diff --git a/src/VM/Core/Runtime/Executor/Insn/InsnInterface.php b/src/VM/Core/Runtime/Executor/Insn/InsnInterface.php
index 4253f0b9..bde3fe20 100644
--- a/src/VM/Core/Runtime/Executor/Insn/InsnInterface.php
+++ b/src/VM/Core/Runtime/Executor/Insn/InsnInterface.php
@@ -7,4 +7,8 @@
 interface InsnInterface
 {
     public static function of(int $value): self;
+
+    public function name(): string;
+
+    public function value(): int;
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAdjuststack.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAdjuststack.php
index 2fa92e6b..fb26ed1a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAdjuststack.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAdjuststack.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAnytostring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAnytostring.php
index e429cfea..09a65495 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAnytostring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinAnytostring.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchnil.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchnil.php
index ecfc3fd0..1bf174e6 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchnil.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinBranchnil.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckkeyword.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckkeyword.php
index 50c35b61..a6fc16ad 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckkeyword.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckkeyword.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckmatch.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckmatch.php
index e630dffe..4507406a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckmatch.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinCheckmatch.php
@@ -41,7 +41,7 @@ public function process(): ProcessedStatus
 
         // TODO: We will implement other types
         if ($type->valueOf() !== CheckMatchType::RESCUE->value) {
-            throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor with %d type is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value, $type->valueOf()));
+            throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor with %d type is not implemented yet', strtolower($this->insn->name()), $this->insn->value(), $type->valueOf()));
         }
 
         $compareBy = $this->stackAsRubyClass();
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinChecktype.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinChecktype.php
index 892eed51..2dc0a0da 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinChecktype.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinChecktype.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatstrings.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatstrings.php
index 81c89363..7a05f4fd 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatstrings.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinConcatstrings.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinesmethod.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinesmethod.php
index 0f872621..7110d355 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinesmethod.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDefinesmethod.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuphash.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuphash.php
index 4d8256cf..e8573b17 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuphash.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDuphash.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDupn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDupn.php
index 1240ba35..c5a21d34 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDupn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinDupn.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinExpandarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinExpandarray.php
index cbcded0c..c0ee96cf 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinExpandarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinExpandarray.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetclassvariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetclassvariable.php
index a60aad4c..70108312 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetclassvariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetclassvariable.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetconstant.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetconstant.php
index e8c0422b..99ff6712 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetconstant.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetconstant.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetspecial.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetspecial.php
index 1e805b37..4be27c3e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetspecial.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinGetspecial.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinIntern.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinIntern.php
index 2be6cf8c..7d3b3451 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinIntern.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinIntern.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokebuiltin.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokebuiltin.php
index 9cc24259..f33066b3 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokebuiltin.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokebuiltin.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokesuper.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokesuper.php
index 41ffd6b1..4962b4a3 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokesuper.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinInvokesuper.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarraykwsplat.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarraykwsplat.php
index 8e3f3dc6..8bee1636 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarraykwsplat.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinNewarraykwsplat.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinObjtostring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinObjtostring.php
index 1e569154..c378b9cc 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinObjtostring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinObjtostring.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOnce.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOnce.php
index 5c7f9269..dbb406fa 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOnce.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOnce.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptArefWith.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptArefWith.php
index 60242e76..5ae4b24d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptArefWith.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptArefWith.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAset.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAset.php
index 5e49ae9e..c25aed5e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAset.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAset.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAsetWith.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAsetWith.php
index 835815b5..6b643f45 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAsetWith.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptAsetWith.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegate.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegate.php
index 9a045ac4..fb786764 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegate.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegate.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegateLeave.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegateLeave.php
index 030185aa..af0b1245 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegateLeave.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptInvokebuiltinDelegateLeave.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLength.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLength.php
index 61e48937..e3e2321b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLength.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptLength.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNeq.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNeq.php
index e3da7aa3..a1120d7c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNeq.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNeq.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMax.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMax.php
index 6dfa259f..3111f58c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMax.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMax.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMin.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMin.php
index f10e9cae..07df9854 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMin.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNewarrayMin.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNot.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNot.php
index c7f48b16..75171aec 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNot.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptNot.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptReverse.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptReverse.php
index ad397221..af562117 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptReverse.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptReverse.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSize.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSize.php
index 816aceac..be3d85de 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSize.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSize.php
@@ -51,6 +51,6 @@ public function process(): ProcessedStatus
             return ProcessedStatus::SUCCESS;
         }
 
-        throw new OperationProcessorException(sprintf('The %s is not compatible type %s', strtolower((string) $this->insn->name), ClassHelper::nameBy($recv)));
+        throw new OperationProcessorException(sprintf('The %s is not compatible type %s', strtolower($this->insn->name()), ClassHelper::nameBy($recv)));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrFreeze.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrFreeze.php
index c9f5eba4..490569f9 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrFreeze.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrFreeze.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrUminus.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrUminus.php
index 0dccfdde..fb04dd51 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrUminus.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptStrUminus.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSucc.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSucc.php
index 4cfc13a2..5724b844 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSucc.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinOptSucc.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetblockparam.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetblockparam.php
index c4abd7f5..bf2efb7e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetblockparam.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetblockparam.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetclassvariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetclassvariable.php
index 91482a04..0ab39923 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetclassvariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetclassvariable.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetconstant.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetconstant.php
index 63d1ee38..68687d18 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetconstant.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetconstant.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetn.php
index 1e775325..dc66f5aa 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetn.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetspecial.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetspecial.php
index 9b0c84e0..49d2402a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetspecial.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSetspecial.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSwap.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSwap.php
index cbcaf957..a68470b5 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSwap.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinSwap.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinThrow.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinThrow.php
index 58af5453..fa8caf56 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinThrow.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinThrow.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinToregexp.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinToregexp.php
index 83db7f51..b6830864 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinToregexp.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinToregexp.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAdjuststack.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAdjuststack.php
index 1f04abbc..e22438c7 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAdjuststack.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAdjuststack.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAnytostring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAnytostring.php
index ff0b44fc..785e588f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAnytostring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceAnytostring.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchif.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchif.php
index 49fade20..c976bbc2 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchif.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchif.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchnil.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchnil.php
index 73882504..b80ff080 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchnil.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchnil.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchunless.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchunless.php
index f3e88a0d..ba44d697 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchunless.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceBranchunless.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckkeyword.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckkeyword.php
index 2d0481c2..eb45fe9a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckkeyword.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckkeyword.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckmatch.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckmatch.php
index 9afee2dd..f08c9b7b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckmatch.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceCheckmatch.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceChecktype.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceChecktype.php
index 4863df21..3bac30d9 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceChecktype.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceChecktype.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatarray.php
index 9d559412..5ce01dd2 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatarray.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatstrings.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatstrings.php
index 0326d969..e9ff4721 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatstrings.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceConcatstrings.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefineclass.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefineclass.php
index 7ec3001a..df13b65e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefineclass.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefineclass.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefined.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefined.php
index 8e2ef38b..cde5a502 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefined.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefined.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinemethod.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinemethod.php
index 37d59526..bc073886 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinemethod.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinemethod.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinesmethod.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinesmethod.php
index e39044be..dc867f61 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinesmethod.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDefinesmethod.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDup.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDup.php
index 52dfbd80..d82f158f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDup.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDup.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuparray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuparray.php
index 470efcbe..edb97fe2 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuparray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuparray.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuphash.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuphash.php
index f084a0ba..67f804e7 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuphash.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDuphash.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDupn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDupn.php
index 5dcc443f..cfb77be8 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDupn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceDupn.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceExpandarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceExpandarray.php
index 1f0fc679..8f25f2c3 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceExpandarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceExpandarray.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php
index 9a622b51..811c78fb 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name()()), $this->insn->value()()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparamproxy.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparamproxy.php
index ec138cd1..d98e76f3 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparamproxy.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparamproxy.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetclassvariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetclassvariable.php
index b21dbee3..edc1a0cd 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetclassvariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetclassvariable.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetconstant.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetconstant.php
index 942e1258..90907fc8 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetconstant.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetconstant.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetglobal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetglobal.php
index 839e2f56..24d1da09 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetglobal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetglobal.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetinstancevariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetinstancevariable.php
index 07e32c1b..d57a8528 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetinstancevariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetinstancevariable.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocal.php
index 5a8d88af..7b7af5e5 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocal.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC0.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC0.php
index e40611e5..651fc045 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC0.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC0.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC1.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC1.php
index 2ae83417..a59d0c13 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC1.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetlocalWC1.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetspecial.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetspecial.php
index 29724987..d89659f8 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetspecial.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetspecial.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceIntern.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceIntern.php
index a8a7ee04..da84e899 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceIntern.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceIntern.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokeblock.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokeblock.php
index 06d7ab50..247c5db4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokeblock.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokeblock.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokebuiltin.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokebuiltin.php
index 5ff0bb2e..15785daa 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokebuiltin.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokebuiltin.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokesuper.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokesuper.php
index f42592ff..f162b0d1 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokesuper.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceInvokesuper.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceJump.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceJump.php
index e82e12be..596202a4 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceJump.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceJump.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceLeave.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceLeave.php
index ef02cf2f..70af55a6 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceLeave.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceLeave.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarray.php
index ef475522..a60a4155 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarray.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarraykwsplat.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarraykwsplat.php
index 94a6e038..53977793 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarraykwsplat.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewarraykwsplat.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewhash.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewhash.php
index b7c0e786..6b67e6a3 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewhash.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewhash.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewrange.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewrange.php
index 7f232cb5..8159bd5c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewrange.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNewrange.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNop.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNop.php
index feb55218..fd0e0bf8 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNop.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceNop.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceObjtostring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceObjtostring.php
index 66b94f82..65dc72dc 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceObjtostring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceObjtostring.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOnce.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOnce.php
index c525c1ac..e5f6145a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOnce.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOnce.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAnd.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAnd.php
index c22be6cb..2be568e0 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAnd.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAnd.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAref.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAref.php
index 47bf5051..58f5938c 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAref.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAref.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptArefWith.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptArefWith.php
index 88ba700a..c0dc5268 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptArefWith.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptArefWith.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAset.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAset.php
index 85b987d7..0d31ab82 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAset.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAset.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAsetWith.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAsetWith.php
index 74876b05..c91e07ad 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAsetWith.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptAsetWith.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptCaseDispatch.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptCaseDispatch.php
index f109f06d..0ed6c3d2 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptCaseDispatch.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptCaseDispatch.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptDiv.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptDiv.php
index c68d0081..8c950271 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptDiv.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptDiv.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEmptyP.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEmptyP.php
index 50fbf94a..cddd0a08 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEmptyP.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEmptyP.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEq.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEq.php
index 16a79dda..d6459431 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEq.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptEq.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGe.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGe.php
index aa10a541..d797f946 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGe.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGe.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGetconstantPath.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGetconstantPath.php
index 760869eb..105741d2 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGetconstantPath.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGetconstantPath.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGt.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGt.php
index 7e73b789..85916bea 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGt.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptGt.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegate.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegate.php
index 681ff4d5..eb348df3 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegate.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegate.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegateLeave.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegateLeave.php
index 2933e723..254e210f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegateLeave.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptInvokebuiltinDelegateLeave.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLe.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLe.php
index 8eb991ae..a349d508 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLe.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLe.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLength.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLength.php
index 8e8e4fd8..f16ff615 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLength.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLength.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLt.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLt.php
index 56341149..ab46439e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLt.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLt.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLtlt.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLtlt.php
index ceecd8ec..d45b7d56 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLtlt.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptLtlt.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMinus.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMinus.php
index 10820bba..4afac44a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMinus.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMinus.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMod.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMod.php
index faf19b59..2c7a1329 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMod.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMod.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMult.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMult.php
index b8c2dd9d..c796a7a9 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMult.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptMult.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNeq.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNeq.php
index cc43373c..4e786c38 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNeq.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNeq.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMax.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMax.php
index 56940704..4d362097 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMax.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMax.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMin.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMin.php
index 318a95fb..d692b2a1 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMin.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNewarrayMin.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNilP.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNilP.php
index de307e2b..160dcf80 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNilP.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNilP.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNot.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNot.php
index 34a28d2a..5feb88be 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNot.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptNot.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptOr.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptOr.php
index 40f5c9b6..354415e2 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptOr.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptOr.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptPlus.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptPlus.php
index fe1319f4..83b6b52a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptPlus.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptPlus.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptRegexpmatch2.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptRegexpmatch2.php
index 9908212c..8715f203 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptRegexpmatch2.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptRegexpmatch2.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptReverse.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptReverse.php
index 437402fe..129c523e 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptReverse.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptReverse.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSendWithoutBlock.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSendWithoutBlock.php
index abb37dce..12585550 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSendWithoutBlock.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSendWithoutBlock.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSize.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSize.php
index 084c68f4..527baefd 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSize.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSize.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrFreeze.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrFreeze.php
index c1c08018..2f84576a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrFreeze.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrFreeze.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrUminus.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrUminus.php
index 17a1e70b..b417fb2a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrUminus.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptStrUminus.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSucc.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSucc.php
index 36a5403d..d46efd25 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSucc.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceOptSucc.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePop.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePop.php
index 71829b6b..0e1864d9 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePop.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePop.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutnil.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutnil.php
index b903cd1d..e077bfb1 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutnil.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutnil.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobject.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobject.php
index a82253c5..cc8d7b80 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobject.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobject.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX0.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX0.php
index 5f494ad0..5352596b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX0.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX0.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX1.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX1.php
index 667845c6..4548f47d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX1.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutobjectINT2FIX1.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutself.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutself.php
index c576e907..14f15f39 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutself.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutself.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutspecialobject.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutspecialobject.php
index fec80f57..23856e65 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutspecialobject.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutspecialobject.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutstring.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutstring.php
index a2e1a5a7..9130889a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutstring.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTracePutstring.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSend.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSend.php
index 57b568b5..07704e7a 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSend.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSend.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetblockparam.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetblockparam.php
index f8033e0b..e822eab7 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetblockparam.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetblockparam.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetclassvariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetclassvariable.php
index fd95811d..0e5390de 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetclassvariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetclassvariable.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetconstant.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetconstant.php
index 6832ce9c..2da24ec3 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetconstant.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetconstant.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetglobal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetglobal.php
index b8431574..89934446 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetglobal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetglobal.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetinstancevariable.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetinstancevariable.php
index b737652d..c3f0425b 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetinstancevariable.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetinstancevariable.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocal.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocal.php
index 040eb974..96a031c3 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocal.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocal.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC0.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC0.php
index dc744583..024ec466 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC0.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC0.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC1.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC1.php
index cac15505..8ecbe3b7 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC1.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetlocalWC1.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetn.php
index b0d27f6c..23e3bf4d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetn.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetspecial.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetspecial.php
index 8faddad5..d0472c2f 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetspecial.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSetspecial.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSplatarray.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSplatarray.php
index c0afc534..fbfbdf38 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSplatarray.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSplatarray.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSwap.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSwap.php
index 340010c0..61dfca2d 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSwap.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceSwap.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceThrow.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceThrow.php
index 26d65073..c4968305 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceThrow.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceThrow.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceTopn.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceTopn.php
index 33183c8b..5d46dfd6 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceTopn.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceTopn.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceToregexp.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceToregexp.php
index 78b4bc2f..a26095b9 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceToregexp.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceToregexp.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name), $this->insn->value));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Operation/OperationEntries.php b/src/VM/Core/Runtime/Executor/Operation/OperationEntries.php
index b628bedd..505911cf 100644
--- a/src/VM/Core/Runtime/Executor/Operation/OperationEntries.php
+++ b/src/VM/Core/Runtime/Executor/Operation/OperationEntries.php
@@ -24,8 +24,8 @@ public function __toString(): string
             $result[] = ClassHelper::nameBy($item) . '<' . match ($item::class) {
                 Operation::class => sprintf(
                     '%s<0x%02x>',
-                    strtolower((string) $item->insn->name),
-                    $item->insn->value
+                    strtolower($item->insn->name()),
+                    $item->insn->value()
                 ),
                 Operand::class => ClassHelper::nameBy($item->operand),
                 default => 'none',
diff --git a/src/VM/Core/Runtime/Executor/OperatorCalculatable.php b/src/VM/Core/Runtime/Executor/OperatorCalculatable.php
index 166ce662..98befbd4 100644
--- a/src/VM/Core/Runtime/Executor/OperatorCalculatable.php
+++ b/src/VM/Core/Runtime/Executor/OperatorCalculatable.php
@@ -31,7 +31,7 @@ private function processArithmetic(string $expectedOperator): ProcessedStatus
         $value = null;
         if ($operator instanceof StringSymbol || $operator instanceof SymbolSymbol) {
             if ((string) $operator !== $expectedOperator) {
-                throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor cannot process %s operator because string concatenating was allowed only `%s`', strtolower((string) $this->insn->name), $this->insn->value, $operator, $expectedOperator));
+                throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor cannot process %s operator because string concatenating was allowed only `%s`', strtolower((string) $this->insn->name()), $this->insn->value(), $operator, $expectedOperator));
             }
 
             $value = $obj
@@ -40,7 +40,7 @@ private function processArithmetic(string $expectedOperator): ProcessedStatus
         }
 
         if ($value === null) {
-            throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor cannot process `%s` operator because it was not implemented or cannot comparison operator %s and %s', strtolower((string) $this->insn->name), $this->insn->value, $operator, ClassHelper::nameBy($recv), ClassHelper::nameBy($obj)));
+            throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor cannot process `%s` operator because it was not implemented or cannot comparison operator %s and %s', strtolower((string) $this->insn->name()), $this->insn->value(), $operator, ClassHelper::nameBy($recv), ClassHelper::nameBy($obj)));
         }
 
         $this->context->vmStack()->push(new Operand($value));
diff --git a/src/VM/Core/Runtime/Executor/Validatable.php b/src/VM/Core/Runtime/Executor/Validatable.php
index b5c71a66..d9f81ec2 100644
--- a/src/VM/Core/Runtime/Executor/Validatable.php
+++ b/src/VM/Core/Runtime/Executor/Validatable.php
@@ -17,7 +17,7 @@ public function validateType(string $expectClassName, mixed ...$data): void
                 continue;
             }
 
-            throw new OperationProcessorException(sprintf('The INSN(%s) caught unknown operand %s but this validator expects %s', strtolower((string) $this->insn->name), $operandData::class, $expectClassName));
+            throw new OperationProcessorException(sprintf('The INSN(%s) caught unknown operand %s but this validator expects %s', strtolower((string) $this->insn->name()), $operandData::class, $expectClassName));
         }
     }
 }
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_2/InstructionSequence/Insn.php b/src/VM/Core/Runtime/Kernel/Ruby3_2/InstructionSequence/Insn.php
index 0fe33ba9..5ec031b7 100644
--- a/src/VM/Core/Runtime/Kernel/Ruby3_2/InstructionSequence/Insn.php
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_2/InstructionSequence/Insn.php
@@ -414,4 +414,14 @@ enum Insn: int implements InsnInterface
     case TRACE_PUTOBJECT_INT2FIX_0_ = 200;
 
     case TRACE_PUTOBJECT_INT2FIX_1_ = 201;
+
+    public function name(): string
+    {
+        return $this->name;
+    }
+
+    public function value(): int
+    {
+        return $this->value;
+    }
 }
diff --git a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Insn.php b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Insn.php
index 7bc667c4..cd901d51 100644
--- a/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Insn.php
+++ b/src/VM/Core/Runtime/Kernel/Ruby3_3/InstructionSequence/Insn.php
@@ -215,4 +215,14 @@ enum Insn: int implements InsnInterface
     case TRACE_SETLOCAL_WC_1 = 201;
     case TRACE_PUTOBJECT_INT2FIX_0_ = 202;
     case TRACE_PUTOBJECT_INT2FIX_1_ = 203;
+
+    public function name(): string
+    {
+        return $this->name;
+    }
+
+    public function value(): int
+    {
+        return $this->value;
+    }
 }

From 875b1014424f6b0bc6de76be406fbf0175a26fca Mon Sep 17 00:00:00 2001
From: m3m0r7 <memory.style.serv@gmail.com>
Date: Wed, 27 Dec 2023 01:09:18 +0900
Subject: [PATCH 11/11] Fix PHPStan

---
 .../Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php  | 2 +-
 src/VM/Core/Runtime/Executor/Executor.php                       | 2 +-
 .../Executor/Insn/Processor/BuiltinTraceGetblockparam.php       | 2 +-
 .../Executor/Operation/Processor/OperationProcessorEntries.php  | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php b/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php
index 5f7c314f..dba5cb47 100644
--- a/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php
+++ b/src/VM/Core/Runtime/Executor/Debugger/DefaultExecutorDebugger.php
@@ -80,7 +80,7 @@ public function showExecutedOperations(): void
         $table->setColumnMaxWidth(4, 60);
 
         /**
-         * @var Insn             $insn
+         * @var InsnInterface    $insn
          * @var ContextInterface $context
          * @var int              $memoryUsage
          */
diff --git a/src/VM/Core/Runtime/Executor/Executor.php b/src/VM/Core/Runtime/Executor/Executor.php
index 15502715..74d76ffd 100644
--- a/src/VM/Core/Runtime/Executor/Executor.php
+++ b/src/VM/Core/Runtime/Executor/Executor.php
@@ -291,7 +291,7 @@ private function _execute(ContextInterface|RubyClassInterface ...$arguments): Ex
                 'Illegal finish an executor',
             );
 
-            throw new ExecutorExeption(sprintf('The executor did not finish - maybe did not call the `%s` (0x%02x)', strtolower((string) Insn::LEAVE->name), Insn::LEAVE->value));
+            throw new ExecutorExeption('The executor did not finish - maybe did not call the `leave` opcode');
         }
 
         if (count($operations) !== $this->context->programCounter()->pos()) {
diff --git a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php
index 811c78fb..4a070aab 100644
--- a/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php
+++ b/src/VM/Core/Runtime/Executor/Insn/Processor/BuiltinTraceGetblockparam.php
@@ -30,6 +30,6 @@ public function after(): void {}
 
     public function process(): ProcessedStatus
     {
-        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower((string) $this->insn->name()()), $this->insn->value()()));
+        throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not implemented yet', strtolower($this->insn->name()), $this->insn->value()));
     }
 }
diff --git a/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorEntries.php b/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorEntries.php
index 7c09d515..5375f90e 100644
--- a/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorEntries.php
+++ b/src/VM/Core/Runtime/Executor/Operation/Processor/OperationProcessorEntries.php
@@ -28,7 +28,7 @@ public function get(mixed $index): OperationProcessorInterface
 
         $processor = parent::get($index);
         if (!$processor instanceof OperationProcessorInterface) {
-            throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not registered', strtolower((string) $index->name), $index->value));
+            throw new OperationProcessorException(sprintf('The `%s` (opcode: 0x%02x) processor is not registered', strtolower($index->name()), $index->value()));
         }
 
         return $processor;