diff --git a/.gitee/ISSUE_TEMPLATE/bug.yml b/.gitee/ISSUE_TEMPLATE/bug.yml
index 6fc2f7a..f65f6a9 100644
--- a/.gitee/ISSUE_TEMPLATE/bug.yml
+++ b/.gitee/ISSUE_TEMPLATE/bug.yml
@@ -69,7 +69,7 @@ body:
     attributes:
       label: 软件版本/分支
       options:
-        - v0.3.0
+        - v0.4.0
         - main
         - dev
         - 其他
diff --git a/.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md b/.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md
index 25132b9..711fceb 100644
--- a/.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md
+++ b/.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md
@@ -20,7 +20,7 @@ https://gitee.com/jcnc-org/snow/blob/main/doc/Git-Management/Git-Management.md
 感谢你的配合！🙏
 -->
 
-# 描述 (Description)
+## 描述 (Description)
 
 请简要描述本次变更的目的和内容。
 
diff --git a/.gitignore b/.gitignore
index f7e7803..21e01df 100644
--- a/.gitignore
+++ b/.gitignore
@@ -37,3 +37,6 @@ target/
 /.idea/
 /Snow.tar
 /src/main/java/org/jcnc/snow/compiler/ir.tar
+
+### Snow 虚拟机指令 ###
+*.water
diff --git a/.run/Demo1.run.xml b/.run/Demo1.run.xml
index eb7dfb1..55005c8 100644
--- a/.run/Demo1.run.xml
+++ b/.run/Demo1.run.xml
@@ -1,9 +1,9 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Demo1" type="Application" factoryName="Application" folderName="Demo" activateToolWindowBeforeRun="false">
     <option name="ALTERNATIVE_JRE_PATH" value="graalvm-ce-23" />
-    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.compiler.cli.SnowCompiler" />
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
     <module name="Snow" />
-    <option name="PROGRAM_PARAMETERS" value="-d playground/Demo1" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo1 -o target/Demo1" />
     <extension name="coverage">
       <pattern>
         <option name="PATTERN" value="org.jcnc.snow.compiler.parser.preprocessor.lexer.impl.api.*" />
diff --git a/.run/Demo10.run.xml b/.run/Demo10.run.xml
new file mode 100644
index 0000000..94bfc43
--- /dev/null
+++ b/.run/Demo10.run.xml
@@ -0,0 +1,17 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Demo10" type="Application" factoryName="Application" folderName="Demo" activateToolWindowBeforeRun="false">
+    <option name="ALTERNATIVE_JRE_PATH" value="graalvm-ce-23" />
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
+    <module name="Snow" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo10 -o target/Demo10" />
+    <extension name="coverage">
+      <pattern>
+        <option name="PATTERN" value="org.jcnc.snow.compiler.parser.preprocessor.lexer.impl.api.*" />
+        <option name="ENABLED" value="true" />
+      </pattern>
+    </extension>
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/.run/Demo2.run.xml b/.run/Demo2.run.xml
index 59233b4..882e77a 100644
--- a/.run/Demo2.run.xml
+++ b/.run/Demo2.run.xml
@@ -1,9 +1,9 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Demo2" type="Application" factoryName="Application" folderName="Demo" activateToolWindowBeforeRun="false">
     <option name="ALTERNATIVE_JRE_PATH" value="graalvm-ce-23" />
-    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.compiler.cli.SnowCompiler" />
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
     <module name="Snow" />
-    <option name="PROGRAM_PARAMETERS" value="-d playground/Demo2" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo2 -o target/Demo2" />
     <extension name="coverage">
       <pattern>
         <option name="PATTERN" value="org.jcnc.snow.compiler.parser.preprocessor.lexer.impl.api.*" />
diff --git a/.run/Demo3.run.xml b/.run/Demo3.run.xml
index 31c1fdb..a949e95 100644
--- a/.run/Demo3.run.xml
+++ b/.run/Demo3.run.xml
@@ -1,9 +1,9 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Demo3" type="Application" factoryName="Application" folderName="Demo" activateToolWindowBeforeRun="false">
     <option name="ALTERNATIVE_JRE_PATH" value="graalvm-ce-23" />
-    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.compiler.cli.SnowCompiler" />
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
     <module name="Snow" />
-    <option name="PROGRAM_PARAMETERS" value="-d playground/Demo3" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo3 -o target/Demo3" />
     <extension name="coverage">
       <pattern>
         <option name="PATTERN" value="org.jcnc.snow.compiler.parser.preprocessor.lexer.impl.api.*" />
diff --git a/.run/Demo4.run.xml b/.run/Demo4.run.xml
index d325c13..57afa15 100644
--- a/.run/Demo4.run.xml
+++ b/.run/Demo4.run.xml
@@ -1,9 +1,9 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Demo4" type="Application" factoryName="Application" folderName="Demo" activateToolWindowBeforeRun="false">
     <option name="ALTERNATIVE_JRE_PATH" value="graalvm-ce-23" />
-    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.compiler.cli.SnowCompiler" />
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
     <module name="Snow" />
-    <option name="PROGRAM_PARAMETERS" value="-d playground/Demo4" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo4 -o target/Demo4" />
     <extension name="coverage">
       <pattern>
         <option name="PATTERN" value="org.jcnc.snow.compiler.parser.preprocessor.lexer.impl.api.*" />
diff --git a/.run/Demo5.run.xml b/.run/Demo5.run.xml
index a12479e..cb543d1 100644
--- a/.run/Demo5.run.xml
+++ b/.run/Demo5.run.xml
@@ -1,9 +1,9 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Demo5" type="Application" factoryName="Application" folderName="Demo" activateToolWindowBeforeRun="false">
     <option name="ALTERNATIVE_JRE_PATH" value="graalvm-ce-23" />
-    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.compiler.cli.SnowCompiler" />
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
     <module name="Snow" />
-    <option name="PROGRAM_PARAMETERS" value="-d playground/Demo5" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo5 -o target/Demo5" />
     <extension name="coverage">
       <pattern>
         <option name="PATTERN" value="org.jcnc.snow.compiler.parser.preprocessor.lexer.impl.api.*" />
diff --git a/.run/Demo6.run.xml b/.run/Demo6.run.xml
index 236a33b..b6c3fdc 100644
--- a/.run/Demo6.run.xml
+++ b/.run/Demo6.run.xml
@@ -1,9 +1,9 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Demo6" type="Application" factoryName="Application" folderName="Demo" activateToolWindowBeforeRun="false">
     <option name="ALTERNATIVE_JRE_PATH" value="graalvm-ce-23" />
-    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.compiler.cli.SnowCompiler" />
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
     <module name="Snow" />
-    <option name="PROGRAM_PARAMETERS" value="-d playground/Demo6" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo6 -o target/Demo6" />
     <extension name="coverage">
       <pattern>
         <option name="PATTERN" value="org.jcnc.snow.compiler.parser.preprocessor.lexer.impl.api.*" />
diff --git a/.run/Demo7.run.xml b/.run/Demo7.run.xml
index 2addca0..6f25770 100644
--- a/.run/Demo7.run.xml
+++ b/.run/Demo7.run.xml
@@ -1,9 +1,9 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Demo7" type="Application" factoryName="Application" folderName="Demo" activateToolWindowBeforeRun="false">
     <option name="ALTERNATIVE_JRE_PATH" value="graalvm-ce-23" />
-    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.compiler.cli.SnowCompiler" />
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
     <module name="Snow" />
-    <option name="PROGRAM_PARAMETERS" value="-d playground/Demo7" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo7 -o target/Demo7" />
     <extension name="coverage">
       <pattern>
         <option name="PATTERN" value="org.jcnc.snow.compiler.parser.preprocessor.lexer.impl.api.*" />
diff --git a/.run/Demo8.run.xml b/.run/Demo8.run.xml
new file mode 100644
index 0000000..4bb76fe
--- /dev/null
+++ b/.run/Demo8.run.xml
@@ -0,0 +1,17 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Demo8" type="Application" factoryName="Application" folderName="Demo" activateToolWindowBeforeRun="false">
+    <option name="ALTERNATIVE_JRE_PATH" value="graalvm-ce-23" />
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
+    <module name="Snow" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo8 -o target/Demo8" />
+    <extension name="coverage">
+      <pattern>
+        <option name="PATTERN" value="org.jcnc.snow.compiler.parser.preprocessor.lexer.impl.api.*" />
+        <option name="ENABLED" value="true" />
+      </pattern>
+    </extension>
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/.run/Demo9.run.xml b/.run/Demo9.run.xml
new file mode 100644
index 0000000..a6bf203
--- /dev/null
+++ b/.run/Demo9.run.xml
@@ -0,0 +1,17 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Demo9" type="Application" factoryName="Application" folderName="Demo" activateToolWindowBeforeRun="false">
+    <option name="ALTERNATIVE_JRE_PATH" value="graalvm-ce-23" />
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
+    <module name="Snow" />
+    <option name="PROGRAM_PARAMETERS" value="compile run -d playground/Demo9 -o target/Demo9" />
+    <extension name="coverage">
+      <pattern>
+        <option name="PATTERN" value="org.jcnc.snow.compiler.parser.preprocessor.lexer.impl.api.*" />
+        <option name="ENABLED" value="true" />
+      </pattern>
+    </extension>
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/.run/Help.run.xml b/.run/Help.run.xml
new file mode 100644
index 0000000..849a3b4
--- /dev/null
+++ b/.run/Help.run.xml
@@ -0,0 +1,16 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Help" type="Application" factoryName="Application">
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
+    <module name="Snow" />
+    <option name="PROGRAM_PARAMETERS" value="--help" />
+    <extension name="coverage">
+      <pattern>
+        <option name="PATTERN" value="org.jcnc.snow.cli.SnowCLI" />
+        <option name="ENABLED" value="true" />
+      </pattern>
+    </extension>
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/.run/Version.run.xml b/.run/Version.run.xml
new file mode 100644
index 0000000..5816f30
--- /dev/null
+++ b/.run/Version.run.xml
@@ -0,0 +1,16 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Version" type="Application" factoryName="Application">
+    <option name="MAIN_CLASS_NAME" value="org.jcnc.snow.cli.SnowCLI" />
+    <module name="Snow" />
+    <option name="PROGRAM_PARAMETERS" value="--version" />
+    <extension name="coverage">
+      <pattern>
+        <option name="PATTERN" value="org.jcnc.snow.cli.SnowCLI" />
+        <option name="ENABLED" value="true" />
+      </pattern>
+    </extension>
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/README.md b/README.md
index 411486f..74438c3 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="doc/README/IMG/IMG_Snow_icon_128.svg" alt="Snow Icon">
+  <img src="docs/README/IMG/icon/IMG_Snow_icon_128.svg" alt="Snow Icon">
 <h1 align="center" style="margin: 30px 0 30px; font-weight: bold;">Snow编程语言</h1>
 
 <p align="center">
@@ -11,8 +11,8 @@
     <a href="https://gitee.com/jcnc-org/snow/blob/main/LICENSE">
         <img src="https://img.shields.io/badge/%20license-Apache--2.0%20-blue" alt="">
     </a>
-    <a href="https://gitee.com/jcnc-org/snow/tree/v0.3.0/">
-        <img src="https://img.shields.io/badge/version-v0.3.0-blue" alt="">
+    <a href="https://gitee.com/jcnc-org/snow/tree/v0.4.0/">
+        <img src="https://img.shields.io/badge/version-v0.4.0-blue" alt="">
     </a>
 </p>
 
@@ -30,37 +30,55 @@
 
 ## 项目简介
 
-Snow 语言是一个正在发展的编程语言,采用类模块（module）语法风格,支持函数定义和类型注解。它设计目标是让大型语言模型（LLM）更容易生成和理解编程代码。该项目实现了 Snow 语言的完整编译流程,包括词法分析,语法分析,语义分析,中间表示（IR）生成以及最终的虚拟机（VM）指令生成和执行器。通过 Snow 编译器,可以将 `.snow` 源文件编译为中间表示和自定义的虚拟机指令,并在内置的虚拟机上直接运行。
+Snow 是一门受 LLM 时代启发的、面向 AI 友好的编程语言。它设计目标是让 LLM 更容易生成和理解编程代码。
+
+该项目实现了 Snow
+语言的完整编译流程,包括词法分析,语法分析,语义分析,中间表示（IR）生成以及最终的虚拟机（VM）指令生成和执行器，提供从源码到字节码再到自研编程语言虚拟机 (
+SnowVM) 的完整编译-执行链路。
+
+通过 Snow 编译器,可以将 `.snow` 源文件编译为 `.water`虚拟机指令,并在 SnowVM 上直接运行。
+
+从源码编译、构建管理、依赖管理、项目标准化、可视化调试面板到原生镜像发布，全部由 Snow 官方工具完成，降低学习与集成成本。
 
 ## 背景理念
 
-Snow 语言受到 LLM 驱动代码生成趋势的启发,强调简单而清晰的语法和严格的类型系统,以帮助人工智能模型更好地理解程序结构。语言使用显式的 `module` 声明来组织代码,用 `function`,`parameter`,`return_type`,`body` 等关键字分隔不同代码块,语法结构固定且易读。此外,Snow 实现了语义分析来检查变量作用域和类型一致性,在编译阶段捕获错误并确保生成的中间代码正确无误。这种自上而下的编译流程,使得代码设计和生成更加模块化,可解释,也有利于调试和优化。
+Snow 语言受到 LLM 驱动代码生成趋势的启发,强调简单而清晰的语法和严格的类型系统,以帮助 LLM 更好地理解程序。
 
-相关背景: [心路历程](doc/Snow's-Journey/Snow's-Journey.md)
+语言使用显式的 `module` 声明来组织代码,用 `function`,`parameter`,`return_type`,`body` 等关键字分隔不同代码块,语法结构固定且易读。此外,Snow
+实现了语义分析来检查变量作用域和类型一致性,在编译阶段捕获错误并确保生成的中间代码正确无误。这种自上而下的编译流程,使得代码设计和生成更加模块化,可解释,也有利于调试和优化。
 
-## 下载Snow发行版
-
-访问:  https://gitee.com/jcnc-org/snow/releases
-
-## 相关文档
-
-[Git 管理规范](doc/Git-Management/Git-Management.md)
+相关背景: [心路历程](docs/Snow-Lang-Journey/Snow-Lang-Journey.md)
 
 ## 功能特性
 
-* **模块化语法**：支持顶层的 `module:` 声明和 `import:` 导入语句,用于组织代码和依赖管理。
-* **函数与类型**：支持函数定义,函数参数和返回值。在函数体中可以声明变量并进行类型检查。
-* **丰富语句**：支持变量声明（`declare name:Type`,可选初始化）,条件语句（`if ... end if`）,循环语句（`loop ... end loop`）,返回语句等。
-* **表达式解析**：实现了 Pratt 算法的表达式解析器,支持算术,比较和逻辑运算,以及函数调用,成员访问等操作。
-* **完整编译器前端**：包含词法分析器（Lexer）,语法分析器（Parser）和语义分析器,对源代码生成抽象语法树（AST）并检查类型/作用域。
-* **中间表示（IR）**：将高层 AST 转换为自定义的三地址式 IR（Intermediate Representation）,结构清晰便于后端优化。
-* **后端指令生成**：IR 模块通过线性扫描寄存器分配器映射寄存器,使用指令生成器将 IR 翻译为定制的 VM 指令集。
-* **虚拟机执行**：自带虚拟机引擎（VirtualMachineEngine）,能够加载并执行生成的指令序列,支持调试模式输出虚拟机状态。
-* **调试与输出**：编译过程会输出源码,AST（JSON 格式）,IR 和最终生成的 VM 代码,方便用户查看编译中间结果和调试。
+| 类别       | 关键特性                                                                                              |
+|----------|---------------------------------------------------------------------------------------------------|
+| 语言层      | `module` / `import` / `function` / `loop` / `if–else` / Pratt 表达式解析<br>静态类型检查 & 作用域分析             |
+| 编译器前端    | **Lexer / Parser / Semantic Analyzer** 全栈自研，生成 JSON-AST                                           |
+| IR & 后端  | 三地址式 IR ➜ 线性扫描寄存器分配 ➜ SnowVM 指令                                                                   |
+| 虚拟机      | 栈 + 寄存器混合架构、GUI 局部变量监视                                                                            |
+| snow pkg | - `.cloud` DSL 描述项目、依赖与构建<br>- 预设 `clean / compile / run / package / publish` 任务<br>- 离线缓存与远程仓库解析 |
+| CLI      | `snow init`, `snow compile`, `snow run`, `snow clean`, `snow build`, `snow generate`              |
+
+## Snow-Lang 官网
+
+[https://snow-lang.com](https://snow-lang.com)
+
+## 下载 Snow 发行版
+
+[https://gitee.com/jcnc-org/snow/releases](https://gitee.com/jcnc-org/snow/releases)
+
+## 相关文档
+
+[Git 管理规范](docs/Snow-Lang-Git-Management/Snow-Lang-Git-Management.md)
+
+[SnowVM OpCode 指令表](docs/SnowVM-OpCode/SnowVM-OpCode.md)
+
+[Snow-Lang GraalVM AOT 打包指南](docs/Snow-Lang-GraalVM-AOT-Native-Image-Package/Snow-Lang-GraalVM-AOT-Native-Image-Package.md)
 
 ## 开发计划
 
-[Snow 语言现状和下一阶段开发路线图-2025-06-11](doc/Snow's-current-language-situation-and-the-development-roadmap-for-the-next-stage/Snow's-current-language-situation-and-the-development-roadmap-for-the-next-stage.md)
+~~[Snow 语言现状和下一阶段开发路线图-2025-06-11-已废弃](docs/Snow-Lang-Roadmap/Snow-Lang-Roadmap-2025-06-11.md)~~
 
 ## 开发环境安装
 
@@ -76,199 +94,277 @@ Snow 语言受到 LLM 驱动代码生成趋势的启发,强调简单而清晰的
 
 3. **运行项目**
 
-   使用IDEA配置好的运行配置SnowCompiler
+   使用IDEA配置好的运行配置 `Demo1`
 
-   ![IMG_运行配置文件_1.png](doc/README/IMG/IMG_Run-Profile_1.png)
+   ![IMG_运行配置文件_1.png](docs/README/IMG/IMG_Run-Profile_1.png)
 
 4. **运行成功**
-
-``` snow
-## 源代码 (main.snow)
-module: Main
-    import:Math
-    function: main
-        parameter:
-        return_type: int
-        body:
-            Math.factorial(6L,1L)
-            return 0
-        end body
-    end function
-end module
-
-## 源代码 (test.snow)
-module: Math
-    function: factorial
-        parameter:
-            declare n1: long
-            declare n2: long
-        return_type: long
-        body:
-           return n1+n2
-        end body
-    end function
-end module
-
-## 编译器输出
-### AST
-[
-  {
-    "type": "Module",
-    "name": "Main",
-    "imports": [
-      {
-        "module": "Math",
-        "type": "Import"
-      }
-    ],
-    "functions": [
-      {
-        "type": "Function",
-        "name": "main",
-        "parameters": [
-          
+    
+   `````snow   
+    ## 编译器输出
+    ### Snow 源代码
+    #### Main.snow
+    module: Main
+        import:Math
+        function: main
+            return_type: int
+            body:
+                Math.add(6,1)
+                return 0
+            end body
+        end function
+    end module
+    #### Math.snow
+    module: Math
+        function: add
+            parameter:
+                declare n1: int
+                declare n2: int
+            return_type: int
+            body:
+            return n1 + n2
+            end body
+        end function
+    end module
+    ### AST
+    [
+    {
+        "type": "Module",
+        "name": "Main",
+        "imports": [
+        {
+            "module": "Math",
+            "type": "Import"
+        }
         ],
-        "returnType": "int",
-        "body": [
-          {
-            "type": "ExpressionStatement",
-            "expression": {
-              "type": "CallExpression",
-              "callee": {
-                "type": "MemberExpression",
-                "object": {
-                  "type": "Identifier",
-                  "name": "Math"
+        "functions": [
+        {
+            "type": "Function",
+            "name": "main",
+            "parameters": [
+            
+            ],
+            "returnType": "int",
+            "body": [
+            {
+                "type": "ExpressionStatement",
+                "expression": {
+                "type": "CallExpression",
+                "callee": {
+                    "type": "MemberExpression",
+                    "object": {
+                    "type": "Identifier",
+                    "name": "Math"
+                    },
+                    "member": "add"
                 },
-                "member": "factorial"
-              },
-              "arguments": [
-                {
-                  "type": "NumberLiteral",
-                  "value": "6L"
-                },
-                {
-                  "type": "NumberLiteral",
-                  "value": "1L"
+                "arguments": [
+                    {
+                    "type": "NumberLiteral",
+                    "value": "6"
+                    },
+                    {
+                    "type": "NumberLiteral",
+                    "value": "1"
+                    }
+                ]
+                }
+            },
+            {
+                "type": "Return",
+                "value": {
+                "type": "NumberLiteral",
+                "value": "0"
                 }
-              ]
             }
-          },
-          {
-            "type": "Return",
-            "value": {
-              "type": "NumberLiteral",
-              "value": "0"
-            }
-          }
+            ]
+        }
         ]
-      }
-    ]
-  },
-  {
-    "type": "Module",
-    "name": "Math",
-    "imports": [
-      
-    ],
-    "functions": [
-      {
-        "type": "Function",
-        "name": "factorial",
-        "parameters": [
-          {
-            "name": "n1",
-            "type": "long"
-          },
-          {
-            "name": "n2",
-            "type": "long"
-          }
+    },
+    {
+        "type": "Module",
+        "name": "Math",
+        "imports": [
+        
         ],
-        "returnType": "long",
-        "body": [
-          {
-            "type": "Return",
-            "value": {
-              "type": "BinaryExpression",
-              "left": {
-                "type": "Identifier",
-                "name": "n1"
-              },
-              "operator": "+",
-              "right": {
-                "type": "Identifier",
-                "name": "n2"
-              }
+        "functions": [
+        {
+            "type": "Function",
+            "name": "add",
+            "parameters": [
+            {
+                "name": "n1",
+                "type": "int"
+            },
+            {
+                "name": "n2",
+                "type": "int"
             }
-          }
+            ],
+            "returnType": "int",
+            "body": [
+            {
+                "type": "Return",
+                "value": {
+                "type": "BinaryExpression",
+                "left": {
+                    "type": "Identifier",
+                    "name": "n1"
+                },
+                "operator": "+",
+                "right": {
+                    "type": "Identifier",
+                    "name": "n2"
+                }
+                }
+            }
+            ]
+        }
         ]
-      }
+    }
     ]
-  }
-]
-### IR
-func main() {
-  %0 = CONST 6
-  %1 = CONST 1
-  %2 = CALL Math.factorial, %0, %1
-  %3 = CONST 0
-  RET %3
-}
-func factorial(%0, %1) {
-  %2 = ADD_L64 %0, %1
-  RET %2
-}
-
-### VM code
-112 6
-152 0
-112 1
-152 1
-162 0
-162 1
-201 12 2
-152 2
-111 0
-151 3
-161 3
-255
-162 0
-162 1
-11
-152 2
-162 2
-202
-Calling function at address: 12
-Return 7
-Process has ended
+    ### IR
+    func main() {
+    %0 = CONST 6
+    %1 = CONST 1
+    %2 = CALL Math.add, %0, %1
+    %3 = CONST 0
+    RET %3
+    }
+    func add(%0, %1) {
+    %2 = ADD_I32 %0, %1
+    RET %2
+    }
 
 
-### VM Local Variable Table:
-0: 6
-1: 1
-2: 7
-3: 0
+    ### VM code
+    0000: I_PUSH     6
+    0001: I_STORE    0
+    0002: I_PUSH     1
+    0003: I_STORE    1
+    0004: I_LOAD     0
+    0005: I_LOAD     1
+    0006: CALL       12 2
+    0007: I_STORE    2
+    0008: I_PUSH     0
+    0009: I_STORE    3
+    0010: I_LOAD     3
+    0011: HALT       
+    0012: I_LOAD     0
+    0013: I_LOAD     1
+    0014: I_ADD      
+    0015: I_STORE    2
+    0016: I_LOAD     2
+    0017: RET        
+    Written to D:\Devs\IdeaProjects\Snow\target\Demo1.water
 
-```
+    === Launching VM ===
+    Calling function at address: 12
+    Return 7
+    Process has ended
+
+    Operand Stack state:[0]
+
+    --- Call Stack State ---
 
 
-## 编译Snow源代码
+    ### VM Local Variable Table:
+    0: 6
+    1: 1
+    2: 7
+    3: 0
+    `````
+    
+## 编译 Snow 源代码
 
-1. **运行编译器**：
-   运行 Snow 来编译 `.snow` 源文件 (Windows环境) 并且在Snow虚拟机运行,默认以 DEBUG 模式显示执行过程和状态。例如：
+### 1. 独立编译 (Standalone Compilation)
+
+独立编译不依赖 `.cloud` 文件，而是直接使用 `Snow` 编译器进行 `.snow` 文件的编译和执行。
+
+#### 独立编译步骤：
+
+1. **运行编译器：**
+   你可以通过以下命令来编译单个或多个 `.snow` 文件，或者递归编译一个目录中的所有 `.snow` 源文件为`.water`虚拟机指令。
+
+    * **单个文件编译：**
+
+      ```bash
+      Snow complete [SnowCode].snow
+      ```
+
+    * **多个文件编译：**
+
+      ```bash
+      Snow complete [SnowCode1].snow [SnowCode2].snow [SnowCode3].snow -o [Name]
+      ```
+
+    * **目录递归编译：**
+
+      ```bash
+      Snow -d path/to/source_dir
+      ```
+
+2. **查看编译输出：**
+   编译过程会输出源代码、抽象语法树（AST）、中间表示（IR）以及虚拟机指令等内容。你可以看到如下几个分段输出：
+
+    * **AST**（抽象语法树）部分以 JSON 格式输出。
+    * **IR**（中间表示）部分会列出逐行的中间代码。
+    * **VM code**（虚拟机指令）会展示虚拟机的字节码指令。
+
+3. **默认执行模式：**
+   编译器会在 **DEBUG 模式** 下运行，显示详细的执行过程和状态，并且在虚拟机中执行编译后的代码，最后会打印出所有局部变量的值。
+
+---
+
+### 2. **集成编译 (Integrated Compilation)**
+
+集成编译需要使用 `.cloud` 文件来指定项目的配置和结构，适用于项目标准化、依赖管理、构建管理和项目分发等场景。
+
+#### 集成编译命令：
+
+1. **基本用法：**
 
    ```bash
-   # 单个文件编译
-   Snow.exe [SnowCode].snow
-   # 多个文件编译
-   Snow.exe [SnowCode1].snow [SnowCode2].snow [SnowCode3].snow 
-   # 目录递归编译（-d 参数）
-   Snow.exe -d path/to/source_dir
+     snow [OPTIONS] <command>
+   ```
 
+2. **命令选项：**
 
-   编译器会输出源代码,AST,IR 和 VM 指令等内容,并自动执行虚拟机引擎,最后打印所有局部变量的值
-2. **查看 AST/IR/VM 输出**：在编译器输出中,可看到 `### AST`,`### IR` 和 `### VM code` 等分段内容。AST 部分为 JSON 格式,IR 和 VM 部分为逐行指令文本。
+    * `-h, --help`：显示帮助信息并退出。
+    * `-v, --version`：打印 Snow 编程语言的版本并退出。
+
+3. **可用命令：**
+
+    * `compile`：将 `.snow` 源文件编译成虚拟机字节码文件（`.water`）。此命令会使用 `.cloud` 文件来指导编译过程。
+    * `clean`：清理构建输出和本地缓存，移除中间产物，释放磁盘空间。
+    * `version`：打印 Snow 的版本。
+    * `run`：运行已编译的虚拟机字节码文件（`.water`）。
+    * `init`：初始化一个新项目，生成 `project.cloud` 文件。
+    * `generate`：根据 `project.cloud` 生成项目目录结构。
+    * `build`：构建当前项目，按顺序解析依赖、编译和打包。
+
+4. **例如，执行集成编译命令：**
+
+   ```bash
+   snow compile [SnowCode].snow
+   ```
+
+    * 此命令会使用 `.cloud` 文件中的配置信息来指导编译过程，并生成 `.water`。
+
+5. **使用帮助：**
+   如果你需要了解某个命令的详细选项，可以使用：
+
+   ```bash
+   snow <command> --help
+   ```
+
+   例如，查看 `compile` 命令的具体选项：
+
+   ```bash
+   snow compile --help
+   ```
+
+---
 
 ## 示例代码片段
 
@@ -277,7 +373,6 @@ Process has ended
 ```snow
 module: Math
     function: main
-        parameter:
         return_type: int
         body:
             Math.factorial(6)
@@ -306,32 +401,52 @@ module: Math
         end body
     end function
 end module
-
 ```
 
 上述代码定义了一个名为 `Math` 的模块，其中包含两个函数：
 
 * `main`：不接收任何参数，返回类型为 `int`。在函数体内调用了 `Math.factorial(6)`，然后返回 `0`。
-* `factorial`：接收一个 `int` 类型的参数 `n`，返回类型为 `int`。函数体内先声明并初始化局部变量 `num1` 为 `1`，然后通过一个 `loop` 循环（从 `counter = 1` 到 `counter <= n`）依次将 `num1` 乘以 `counter`，循环结束后返回 `num1`，即 `n` 的阶乘值。
+* `factorial`：接收一个 `int` 类型的参数 `n`，返回类型为 `int`。函数体内先声明并初始化局部变量 `num1` 为 `1`，然后通过一个
+  `loop` 循环（从 `counter = 1` 到 `counter <= n`）依次将 `num1` 乘以 `counter`，循环结束后返回 `num1`，即 `n` 的阶乘值。
 
 
+> 更多示例代码见 [playground 目录](https://gitee.com/jcnc-org/snow/tree/main/playground) 
+
 ## 项目结构说明
 
 * `compiler/`：Snow 编译器源代码目录
 
-    * `cli/`：命令行接口,包括 `SnowCompiler` 主程序
-    * `lexer/`：词法分析模块,负责将源码切分为 Token
-    * `parser/`：语法分析模块,将 Token 流解析为 AST；包括模块解析,函数解析,语句解析等子模块
-    * `semantic/`：语义分析模块,负责符号表管理,类型检查等
-    * `ir/`：中间表示（IR）模块,生成和管理三地址码形式的中间代码
-    * `backend/`：编译器后端模块,将 IR 翻译为虚拟机指令,包含寄存器分配和指令生成器
+    * `lexer/`：词法分析模块，负责将源码切分为 Token
+    * `parser/`：语法分析模块，将 Token 流解析为 AST（含模块/函数/语句解析）
+    * `semantic/`：语义分析模块，负责符号表管理、类型检查等
+    * `ir/`：中间表示（IR）模块，生成并管理三地址码形式的中间代码
+    * `backend/`：编译器后端模块，将 IR 翻译为虚拟机指令，包含寄存器分配和指令生成器
+
 * `vm/`：虚拟机相关源代码目录
 
-    * `commands/`：定义 VM 指令集的具体实现
-    * `engine/`：核心执行引擎,提供指令执行和寄存器栈管理
-    * `execution/`：执行流程控制（按指令顺序执行,分支跳转等）
-    * `io/`：输入输出辅助类（加载指令,文件解析等）
-    * 其他如 `factories/`,`utils/` 等目录包含指令创建和调试工具类
+    * `commands/`：定义 SnowVM 指令集的具体实现
+    * `engine/`：核心执行引擎，提供指令执行和寄存器/栈管理
+    * `execution/`：执行流程控制（按指令顺序执行、分支跳转等）
+    * `io/`：输入输出辅助类（加载指令、文件解析等）
+    * `gui/`：Swing 可视化调试面板，实时展示局部变量表
+    * `factories/`、`utils/`：指令创建、日志调试等公共工具
+
+* `pkg/`：内置构建与包管理器 **snow pkg**
+
+    * `dsl/`：`.cloud` 描述文件解析器
+    * `tasks/`：预设任务实现（`clean · compile · run · package · publish` 等）
+    * `resolver/`：本地/远程仓库解析与缓存
+    * `lifecycle/`：任务生命周期钩子（pre/post 脚本等）
+    * `model/`：项目、依赖、版本等模型
+    * `utils/`：文件、日志、校验和等通用工具
+    * `doc/`：开发者文档与示例 `.cloud` 配置
+
+* `cli/`：独立的命令行前端
+
+    * `commands/`：`compile` / `run` / `pkg` 等子命令实现
+    * `api/`：公共选项解析、终端交互抽象
+    * `utils/`：终端颜色、进度条、异常格式化等
+    * `SnowCLI.java`：CLI 主入口
 
 
 ## 版权声明
diff --git a/doc/README/IMG/IMG_Run-Profile_1.png b/doc/README/IMG/IMG_Run-Profile_1.png
deleted file mode 100644
index b982362..0000000
Binary files a/doc/README/IMG/IMG_Run-Profile_1.png and /dev/null differ
diff --git a/docs/README/IMG/IMG_Run-Profile_1.png b/docs/README/IMG/IMG_Run-Profile_1.png
new file mode 100644
index 0000000..7fb6e7a
Binary files /dev/null and b/docs/README/IMG/IMG_Run-Profile_1.png differ
diff --git a/doc/README/IMG/IMG_Snow_icon_128.png b/docs/README/IMG/icon/IMG_Snow_icon_128.png
similarity index 100%
rename from doc/README/IMG/IMG_Snow_icon_128.png
rename to docs/README/IMG/icon/IMG_Snow_icon_128.png
diff --git a/doc/README/IMG/IMG_Snow_icon_128.svg b/docs/README/IMG/icon/IMG_Snow_icon_128.svg
similarity index 100%
rename from doc/README/IMG/IMG_Snow_icon_128.svg
rename to docs/README/IMG/icon/IMG_Snow_icon_128.svg
diff --git a/doc/README/IMG/IMG_Snow_icon_16.png b/docs/README/IMG/icon/IMG_Snow_icon_16.png
similarity index 100%
rename from doc/README/IMG/IMG_Snow_icon_16.png
rename to docs/README/IMG/icon/IMG_Snow_icon_16.png
diff --git a/doc/README/IMG/IMG_Snow_icon_16.svg b/docs/README/IMG/icon/IMG_Snow_icon_16.svg
similarity index 100%
rename from doc/README/IMG/IMG_Snow_icon_16.svg
rename to docs/README/IMG/icon/IMG_Snow_icon_16.svg
diff --git a/doc/README/IMG/IMG_Snow_icon_256.png b/docs/README/IMG/icon/IMG_Snow_icon_256.png
similarity index 100%
rename from doc/README/IMG/IMG_Snow_icon_256.png
rename to docs/README/IMG/icon/IMG_Snow_icon_256.png
diff --git a/doc/README/IMG/IMG_Snow_icon_256.svg b/docs/README/IMG/icon/IMG_Snow_icon_256.svg
similarity index 100%
rename from doc/README/IMG/IMG_Snow_icon_256.svg
rename to docs/README/IMG/icon/IMG_Snow_icon_256.svg
diff --git a/doc/README/IMG/IMG_Snow_icon_32.png b/docs/README/IMG/icon/IMG_Snow_icon_32.png
similarity index 100%
rename from doc/README/IMG/IMG_Snow_icon_32.png
rename to docs/README/IMG/icon/IMG_Snow_icon_32.png
diff --git a/doc/README/IMG/IMG_Snow_icon_32.svg b/docs/README/IMG/icon/IMG_Snow_icon_32.svg
similarity index 100%
rename from doc/README/IMG/IMG_Snow_icon_32.svg
rename to docs/README/IMG/icon/IMG_Snow_icon_32.svg
diff --git a/doc/README/IMG/IMG_Snow_icon_48.png b/docs/README/IMG/icon/IMG_Snow_icon_48.png
similarity index 100%
rename from doc/README/IMG/IMG_Snow_icon_48.png
rename to docs/README/IMG/icon/IMG_Snow_icon_48.png
diff --git a/doc/README/IMG/IMG_Snow_icon_48.svg b/docs/README/IMG/icon/IMG_Snow_icon_48.svg
similarity index 100%
rename from doc/README/IMG/IMG_Snow_icon_48.svg
rename to docs/README/IMG/icon/IMG_Snow_icon_48.svg
diff --git a/doc/README/IMG/IMG_Snow_icon_64.png b/docs/README/IMG/icon/IMG_Snow_icon_64.png
similarity index 100%
rename from doc/README/IMG/IMG_Snow_icon_64.png
rename to docs/README/IMG/icon/IMG_Snow_icon_64.png
diff --git a/doc/README/IMG/IMG_Snow_icon_64.svg b/docs/README/IMG/icon/IMG_Snow_icon_64.svg
similarity index 100%
rename from doc/README/IMG/IMG_Snow_icon_64.svg
rename to docs/README/IMG/icon/IMG_Snow_icon_64.svg
diff --git a/doc/Git-Management/Git-Management.md b/docs/Snow-Lang-Git-Management/Snow-Lang-Git-Management.md
similarity index 100%
rename from doc/Git-Management/Git-Management.md
rename to docs/Snow-Lang-Git-Management/Snow-Lang-Git-Management.md
diff --git a/docs/Snow-Lang-GraalVM-AOT-Native-Image-Package/Snow-Lang-GraalVM-AOT-Native-Image-Package.md b/docs/Snow-Lang-GraalVM-AOT-Native-Image-Package/Snow-Lang-GraalVM-AOT-Native-Image-Package.md
new file mode 100644
index 0000000..49c971c
--- /dev/null
+++ b/docs/Snow-Lang-GraalVM-AOT-Native-Image-Package/Snow-Lang-GraalVM-AOT-Native-Image-Package.md
@@ -0,0 +1,174 @@
+# Snow-Lang GraalVM AOT 打包指南
+
+## 1. 概述
+
+本文档介绍如何使用 GraalVM 的 AOT（Ahead-of-Time）编译功能将一个 Snow-Lang 项目打包成原生可执行文件（Native Image）。
+
+## 2. 前置条件
+
+1. 操作系统：Linux/macOS/Windows
+2. Java 项目（Maven）
+3. GraalVM（建议 24+ 版本）
+
+## 3. 环境准备
+
+### 3.1 安装 GraalVM
+
+1. 下载对应平台的 GraalVM Community 版本：[https://www.graalvm.org/downloads/](https://www.graalvm.org/downloads/)
+2. 解压并配置环境变量：
+
+3. 验证安装：
+
+```bash
+java -version
+# 应显示 GraalVM 版本信息
+java version "24.0.1" 2025-04-15
+Java(TM) SE Runtime Environment Oracle GraalVM 24.0.1+9.1 (build 24.0.1+9-jvmci-b01)
+Java HotSpot(TM) 64-Bit Server VM Oracle GraalVM 24.0.1+9.1 (build 24.0.1+9-jvmci-b01, mixed mode, sharing)
+```
+### 3.2 Windows 上 Native Image 的先决条件
+
+在 Windows 上，Native Image 需要 Visual Studio 和 Microsoft Visual C++(MSVC)。
+
+1. 从 [visualstudio.microsoft.com](https://visualstudio.microsoft.com/zh-hans/vs/) 下载 Visual Studio Build Tools 2022 或更高版本（C 开发环境）。
+
+2. 通过打开下载的文件来启动安装，然后单击 **继续** 
+
+    ![IMG_VS_1.png](img/IMG_VS_1.png)
+
+3. 在主窗口中选择 **使用 C++ 进行桌面开发** 复选框。在右侧的“安装详细信息”下，确保选择了两个要求，**Windows 11 SDK** 和 **MSVC (…) C++ x64/x86 构建工具**。单击 **安装** 继续。
+
+    ![IMG_VS_2.png](img/IMG_VS_2.png)
+
+您现在能够使用 GraalVM Native Image 进行构建。
+
+## 4. Maven 项目配置文件
+
+通过将以下配置文件添加到 `pom.xml` 中，为 Native Image 启用 Maven 插件：
+
+```xml
+<profiles>
+    <!--
+        原生镜像构建：Linux 平台
+        - 使用 GraalVM 的 native-image 工具，生成静态链接的可执行文件
+        - 依赖 musl libc，需提前安装并配置 musl-gcc 工具链
+    -->
+    <profile>
+        <id>native-linux</id>
+        <activation>
+            <os>
+                <family>unix</family>
+            </os>
+        </activation>
+        <build>
+            <plugins>
+                <plugin>
+                    <groupId>org.graalvm.buildtools</groupId>
+                    <artifactId>native-maven-plugin</artifactId>
+                    <version>${native.maven.plugin.version}</version>
+                    <!-- 启用插件扩展，允许在 build 生命周期中无须额外配置 -->
+                    <extensions>true</extensions>
+                    <executions>
+                        <!-- 打包阶段生成原生可执行文件 -->
+                        <execution>
+                            <id>build-native</id>
+                            <goals>
+                                <!-- compile-no-fork 在当前 JVM 进程中执行 native-image -->
+                                <goal>compile-no-fork</goal>
+                            </goals>
+                            <phase>package</phase>
+                        </execution>
+                        <!-- 测试阶段运行原生镜像的测试 -->
+                        <execution>
+                            <id>test-native</id>
+                            <goals>
+                                <goal>test</goal>
+                            </goals>
+                            <phase>test</phase>
+                        </execution>
+                    </executions>
+                    <configuration>
+                        <buildArgs>
+                            <!-- 静态链接 -->
+                            <buildArg>--static</buildArg>
+                            <!-- 指定 musl libc -->
+                            <buildArg>--libc=musl</buildArg>
+                            <!-- 输出构建报告 -->
+                            <buildArg>--emit build-report</buildArg>
+                            <!-- 优化级别 O2 -->
+                            <buildArg>-O2</buildArg>
+                        </buildArgs>
+                        <environment>
+                            <!-- 指定使用 musl 工具链 -->
+                            <PATH>/opt/musl-1.2.5/bin:${env.PATH}</PATH>
+                            <C_INCLUDE_PATH>/opt/musl-1.2.5/include</C_INCLUDE_PATH>
+                            <LIBRARY_PATH>/opt/musl-1.2.5/lib</LIBRARY_PATH>
+                        </environment>
+                    </configuration>
+                </plugin>
+            </plugins>
+        </build>
+    </profile>
+
+    <!--
+        原生镜像构建：Windows 平台
+        - 使用 GraalVM 的 native-image 工具，生成 Windows 可执行文件
+        - Windows 上不使用 musl，因此不配置静态链接
+    -->
+    <profile>
+        <id>native-windows</id>
+        <activation>
+            <os>
+                <family>Windows</family>
+            </os>
+        </activation>
+        <build>
+            <plugins>
+                <plugin>
+                    <groupId>org.graalvm.buildtools</groupId>
+                    <artifactId>native-maven-plugin</artifactId>
+                    <version>${native.maven.plugin.version}</version>
+                    <extensions>true</extensions>
+                    <executions>
+                        <!-- 打包阶段生成 Windows 可执行文件 -->
+                        <execution>
+                            <id>build-native</id>
+                            <goals>
+                                <goal>compile-no-fork</goal>
+                            </goals>
+                            <phase>package</phase>
+                        </execution>
+                        <!-- 测试阶段运行原生镜像测试 -->
+                        <execution>
+                            <id>test-native</id>
+                            <goals>
+                                <goal>test</goal>
+                            </goals>
+                            <phase>test</phase>
+                        </execution>
+                    </executions>
+                    <configuration>
+                        <buildArgs>
+                            <!-- 输出构建报告 -->
+                            <buildArg>--emit build-report</buildArg>
+                            <!-- 优化级别 O2 -->
+                            <buildArg>-O2</buildArg>
+                        </buildArgs>
+                    </configuration>
+                </plugin>
+            </plugins>
+        </build>
+    </profile>
+</profiles>
+```
+
+## 5. 构建 Native Image
+
+1. 确保项目已在 JVM 下通过测试。
+2. 点击 `Maven` `生命周期` `package`
+
+    ![IMG_Maven_Package_1.png](img/IMG_Maven_Package_1.png)
+
+3. 等待 Native Image 构建完成：这个过程可能较慢（数分钟）。
+4. 可执行文件即可直接运行，无需 JVM。
+    > 生成的可执行文件位于 target/ 目录。
diff --git a/docs/Snow-Lang-GraalVM-AOT-Native-Image-Package/img/IMG_Maven_Package_1.png b/docs/Snow-Lang-GraalVM-AOT-Native-Image-Package/img/IMG_Maven_Package_1.png
new file mode 100644
index 0000000..325e2a8
Binary files /dev/null and b/docs/Snow-Lang-GraalVM-AOT-Native-Image-Package/img/IMG_Maven_Package_1.png differ
diff --git a/docs/Snow-Lang-GraalVM-AOT-Native-Image-Package/img/IMG_VS_1.png b/docs/Snow-Lang-GraalVM-AOT-Native-Image-Package/img/IMG_VS_1.png
new file mode 100644
index 0000000..aaea203
Binary files /dev/null and b/docs/Snow-Lang-GraalVM-AOT-Native-Image-Package/img/IMG_VS_1.png differ
diff --git a/docs/Snow-Lang-GraalVM-AOT-Native-Image-Package/img/IMG_VS_2.png b/docs/Snow-Lang-GraalVM-AOT-Native-Image-Package/img/IMG_VS_2.png
new file mode 100644
index 0000000..e2f773d
Binary files /dev/null and b/docs/Snow-Lang-GraalVM-AOT-Native-Image-Package/img/IMG_VS_2.png differ
diff --git a/doc/Snow's-Journey/Snow's-Journey.md b/docs/Snow-Lang-Journey/Snow-Lang-Journey.md
similarity index 100%
rename from doc/Snow's-Journey/Snow's-Journey.md
rename to docs/Snow-Lang-Journey/Snow-Lang-Journey.md
diff --git a/doc/Snow's-Journey/img/IMG_JNotepad_1.png b/docs/Snow-Lang-Journey/img/IMG_JNotepad_1.png
similarity index 100%
rename from doc/Snow's-Journey/img/IMG_JNotepad_1.png
rename to docs/Snow-Lang-Journey/img/IMG_JNotepad_1.png
diff --git a/doc/Snow's-Journey/img/IMG_JNotepad_2.png b/docs/Snow-Lang-Journey/img/IMG_JNotepad_2.png
similarity index 100%
rename from doc/Snow's-Journey/img/IMG_JNotepad_2.png
rename to docs/Snow-Lang-Journey/img/IMG_JNotepad_2.png
diff --git a/doc/Snow's-current-language-situation-and-the-development-roadmap-for-the-next-stage/Snow's-current-language-situation-and-the-development-roadmap-for-the-next-stage.md b/docs/Snow-Lang-Roadmap/Snow-Lang-Roadmap-2025-06-11.md
similarity index 100%
rename from doc/Snow's-current-language-situation-and-the-development-roadmap-for-the-next-stage/Snow's-current-language-situation-and-the-development-roadmap-for-the-next-stage.md
rename to docs/Snow-Lang-Roadmap/Snow-Lang-Roadmap-2025-06-11.md
diff --git a/docs/SnowVM-OpCode/SnowVM-OpCode.md b/docs/SnowVM-OpCode/SnowVM-OpCode.md
new file mode 100644
index 0000000..4bd5d46
--- /dev/null
+++ b/docs/SnowVM-OpCode/SnowVM-OpCode.md
@@ -0,0 +1,226 @@
+# SnowVM-OpCode
+
+## 1. Byte8 区域（0x0000-0x001F）
+
+| 指令名      | 十六进制   | 说明             |
+|----------|--------|----------------|
+| B\_ADD   | 0x0000 | byte8 加法       |
+| B\_SUB   | 0x0001 | byte8 减法       |
+| B\_MUL   | 0x0002 | byte8 乘法       |
+| B\_DIV   | 0x0003 | byte8 除法       |
+| B\_MOD   | 0x0004 | byte8 取余       |
+| B\_NEG   | 0x0005 | byte8 取负       |
+| B\_INC   | 0x0006 | byte8 自增       |
+| B\_AND   | 0x0007 | byte8 按位与      |
+| B\_OR    | 0x0008 | byte8 按位或      |
+| B\_XOR   | 0x0009 | byte8 按位异或     |
+| B\_PUSH  | 0x000A | byte8 入栈       |
+| B\_LOAD  | 0x000B | byte8 本地变量加载   |
+| B\_STORE | 0x000C | byte8 本地变量存储   |
+| B\_CE    | 0x000D | byte8 等于条件判断   |
+| B\_CNE   | 0x000E | byte8 不等于条件判断  |
+| B\_CG    | 0x000F | byte8 大于条件判断   |
+| B\_CGE   | 0x0010 | byte8 大于等于条件判断 |
+| B\_CL    | 0x0011 | byte8 小于条件判断   |
+| B\_CLE   | 0x0012 | byte8 小于等于条件判断 |
+
+---
+
+## 2. Short16 区域（0x0020-0x003F）
+
+| 指令名      | 十六进制   | 说明               |
+|----------|--------|------------------|
+| S\_ADD   | 0x0020 | short16 加法       |
+| S\_SUB   | 0x0021 | short16 减法       |
+| S\_MUL   | 0x0022 | short16 乘法       |
+| S\_DIV   | 0x0023 | short16 除法       |
+| S\_MOD   | 0x0024 | short16 取余       |
+| S\_NEG   | 0x0025 | short16 取负       |
+| S\_INC   | 0x0026 | short16 自增       |
+| S\_AND   | 0x0027 | short16 按位与      |
+| S\_OR    | 0x0028 | short16 按位或      |
+| S\_XOR   | 0x0029 | short16 按位异或     |
+| S\_PUSH  | 0x002A | short16 入栈       |
+| S\_LOAD  | 0x002B | short16 本地变量加载   |
+| S\_STORE | 0x002C | short16 本地变量存储   |
+| S\_CE    | 0x002D | short16 等于条件判断   |
+| S\_CNE   | 0x002E | short16 不等于条件判断  |
+| S\_CG    | 0x002F | short16 大于条件判断   |
+| S\_CGE   | 0x0030 | short16 大于等于条件判断 |
+| S\_CL    | 0x0031 | short16 小于条件判断   |
+| S\_CLE   | 0x0032 | short16 小于等于条件判断 |
+
+---
+
+## 3. Int32 区域（0x0040-0x005F）
+
+| 指令名      | 十六进制   | 说明             |
+|----------|--------|----------------|
+| I\_ADD   | 0x0040 | int32 加法       |
+| I\_SUB   | 0x0041 | int32 减法       |
+| I\_MUL   | 0x0042 | int32 乘法       |
+| I\_DIV   | 0x0043 | int32 除法       |
+| I\_MOD   | 0x0044 | int32 取余       |
+| I\_NEG   | 0x0045 | int32 取负       |
+| I\_INC   | 0x0046 | int32 自增       |
+| I\_AND   | 0x0047 | int32 按位与      |
+| I\_OR    | 0x0048 | int32 按位或      |
+| I\_XOR   | 0x0049 | int32 按位异或     |
+| I\_PUSH  | 0x004A | int32 入栈       |
+| I\_LOAD  | 0x004B | int32 本地变量加载   |
+| I\_STORE | 0x004C | int32 本地变量存储   |
+| I\_CE    | 0x004D | int32 等于条件判断   |
+| I\_CNE   | 0x004E | int32 不等于条件判断  |
+| I\_CG    | 0x004F | int32 大于条件判断   |
+| I\_CGE   | 0x0050 | int32 大于等于条件判断 |
+| I\_CL    | 0x0051 | int32 小于条件判断   |
+| I\_CLE   | 0x0052 | int32 小于等于条件判断 |
+
+---
+
+## 4. Long64 区域（0x0060-0x007F）
+
+| 指令名      | 十六进制   | 说明              |
+|----------|--------|-----------------|
+| L\_ADD   | 0x0060 | long64 加法       |
+| L\_SUB   | 0x0061 | long64 减法       |
+| L\_MUL   | 0x0062 | long64 乘法       |
+| L\_DIV   | 0x0063 | long64 除法       |
+| L\_MOD   | 0x0064 | long64 取余       |
+| L\_NEG   | 0x0065 | long64 取负       |
+| L\_INC   | 0x0066 | long64 自增       |
+| L\_AND   | 0x0067 | long64 按位与      |
+| L\_OR    | 0x0068 | long64 按位或      |
+| L\_XOR   | 0x0069 | long64 按位异或     |
+| L\_PUSH  | 0x006A | long64 入栈       |
+| L\_LOAD  | 0x006B | long64 本地变量加载   |
+| L\_STORE | 0x006C | long64 本地变量存储   |
+| L\_CE    | 0x006D | long64 等于条件判断   |
+| L\_CNE   | 0x006E | long64 不等于条件判断  |
+| L\_CG    | 0x006F | long64 大于条件判断   |
+| L\_CGE   | 0x0070 | long64 大于等于条件判断 |
+| L\_CL    | 0x0071 | long64 小于条件判断   |
+| L\_CLE   | 0x0072 | long64 小于等于条件判断 |
+
+---
+
+## 5. Float32 区域（0x0080-0x009F）
+
+| 指令名      | 十六进制   | 说明               |
+|----------|--------|------------------|
+| F\_ADD   | 0x0080 | float32 加法       |
+| F\_SUB   | 0x0081 | float32 减法       |
+| F\_MUL   | 0x0082 | float32 乘法       |
+| F\_DIV   | 0x0083 | float32 除法       |
+| F\_MOD   | 0x0084 | float32 取余       |
+| F\_NEG   | 0x0085 | float32 取负       |
+| F\_INC   | 0x0086 | float32 自增       |
+| F\_PUSH  | 0x0087 | float32 入栈       |
+| F\_LOAD  | 0x0088 | float32 本地变量加载   |
+| F\_STORE | 0x0089 | float32 本地变量存储   |
+| F\_CE    | 0x008A | float32 等于条件判断   |
+| F\_CNE   | 0x008B | float32 不等于条件判断  |
+| F\_CG    | 0x008C | float32 大于条件判断   |
+| F\_CGE   | 0x008D | float32 大于等于条件判断 |
+| F\_CL    | 0x008E | float32 小于条件判断   |
+| F\_CLE   | 0x008F | float32 小于等于条件判断 |
+
+---
+
+## 6. Double64 区域（0x00A0-0x00BF）
+
+| 指令名      | 十六进制   | 说明                |
+|----------|--------|-------------------|
+| D\_ADD   | 0x00A0 | double64 加法       |
+| D\_SUB   | 0x00A1 | double64 减法       |
+| D\_MUL   | 0x00A2 | double64 乘法       |
+| D\_DIV   | 0x00A3 | double64 除法       |
+| D\_MOD   | 0x00A4 | double64 取余       |
+| D\_NEG   | 0x00A5 | double64 取负       |
+| D\_INC   | 0x00A6 | double64 自增       |
+| D\_PUSH  | 0x00A7 | double64 入栈       |
+| D\_LOAD  | 0x00A8 | double64 本地变量加载   |
+| D\_STORE | 0x00A9 | double64 本地变量存储   |
+| D\_CE    | 0x00AA | double64 等于条件判断   |
+| D\_CNE   | 0x00AB | double64 不等于条件判断  |
+| D\_CG    | 0x00AC | double64 大于条件判断   |
+| D\_CGE   | 0x00AD | double64 大于等于条件判断 |
+| D\_CL    | 0x00AE | double64 小于条件判断   |
+| D\_CLE   | 0x00AF | double64 小于等于条件判断 |
+
+---
+
+## 7. 类型转换（0x00C0-0x00DF）
+
+| 指令名 | 十六进制   | 说明                 |
+|-----|--------|--------------------|
+| B2S | 0x00C0 | byte8 转 short16    |
+| B2I | 0x00C1 | byte8 转 int32      |
+| B2L | 0x00C2 | byte8 转 long64     |
+| B2F | 0x00C3 | byte8 转 float32    |
+| B2D | 0x00C4 | byte8 转 double64   |
+| S2B | 0x00C5 | short16 转 byte8    |
+| S2I | 0x00C6 | short16 转 int32    |
+| S2L | 0x00C7 | short16 转 long64   |
+| S2F | 0x00C8 | short16 转 float32  |
+| S2D | 0x00C9 | short16 转 double64 |
+| I2B | 0x00CA | int32 转 byte8      |
+| I2S | 0x00CB | int32 转 short16    |
+| I2L | 0x00CC | int32 转 long64     |
+| I2F | 0x00CD | int32 转 float32    |
+| I2D | 0x00CE | int32 转 double64   |
+| L2B | 0x00CF | long64 转 byte8     |
+| L2S | 0x00D0 | long64 转 short16   |
+| L2I | 0x00D1 | long64 转 int32     |
+| L2F | 0x00D2 | long64 转 float32   |
+| L2D | 0x00D3 | long64 转 double64  |
+| F2B | 0x00D4 | float32 转 byte8    |
+| F2S | 0x00D5 | float32 转 short16  |
+| F2I | 0x00D6 | float32 转 int32    |
+| F2L | 0x00D7 | float32 转 long64   |
+| F2D | 0x00D8 | float32 转 double64 |
+| D2B | 0x00D9 | double64 转 byte8   |
+| D2S | 0x00DA | double64 转 short16 |
+| D2I | 0x00DB | double64 转 int32   |
+| D2L | 0x00DC | double64 转 long64  |
+| D2F | 0x00DD | double64 转 float32 |
+
+
+
+---
+
+## 8. 栈控制（0x0100-0x01FF）
+
+| 指令名  | 十六进制   | 说明       |
+|------|--------|----------|
+| POP  | 0x0100 | 弹出栈顶元素   |
+| DUP  | 0x0101 | 复制栈顶元素   |
+| SWAP | 0x0102 | 交换栈顶前两元素 |
+
+---
+
+## 9. 流程控制（0x0200-0x02FF）
+
+| 指令名  | 十六进制/十进制 | 说明    |
+|------|----------|-------|
+| JUMP | 0x0200   | 无条件跳转 |
+| CALL | 0x0201   | 子程序调用 |
+| RET  | 0x0202   | 子程序返回 |
+
+---
+
+## 10. 寄存器控制（0x0300-0x03FF）
+
+| 指令名 | 十六进制   | 说明      |
+|-----|--------|---------|
+| MOV | 0x0300 | 局部变量间赋值 |
+
+---
+
+## 11. 系统控制（0x0400-0x04FF）
+
+| 指令名         | 十六进制   | 说明   |
+|-------------|--------|------|
+| HALT        | 0x0400 | 程序终止 |
+| SYSCALL     | 0x0401 | 系统调用 |
+| DEBUG\_TRAP | 0x0402 | 调试断点 |
\ No newline at end of file
diff --git a/playground/Demo1/Main.snow b/playground/Demo1/Main.snow
index 08eeda8..9058208 100644
--- a/playground/Demo1/Main.snow
+++ b/playground/Demo1/Main.snow
@@ -1,11 +1,10 @@
 module: Main
     import:Math
     function: main
-        parameter:
         return_type: int
         body:
-            Math.factorial(6L,1L)
+            Math.add(6,1)
             return 0
         end body
     end function
-end module
+end module
\ No newline at end of file
diff --git a/playground/Demo1/Math.snow b/playground/Demo1/Math.snow
index bfe8605..2e5963e 100644
--- a/playground/Demo1/Math.snow
+++ b/playground/Demo1/Math.snow
@@ -1,11 +1,11 @@
 module: Math
-    function: factorial
+    function: add
         parameter:
-            declare n1: long
-            declare n2: long
-        return_type: long
+            declare n1: int
+            declare n2: int
+        return_type: int
         body:
-           return n1+n2
+           return n1 + n2
         end body
     end function
 end module
\ No newline at end of file
diff --git a/playground/Demo10/Main.snow b/playground/Demo10/Main.snow
new file mode 100644
index 0000000..de91d63
--- /dev/null
+++ b/playground/Demo10/Main.snow
@@ -0,0 +1,10 @@
+function: main
+    return_type: int
+    body:
+        declare res: boolean = 8L > 7L
+        if res then
+            return 131
+        end if
+        return 65537
+    end body
+end function
\ No newline at end of file
diff --git a/playground/Demo8/Main.snow b/playground/Demo8/Main.snow
new file mode 100644
index 0000000..8ff76af
--- /dev/null
+++ b/playground/Demo8/Main.snow
@@ -0,0 +1,12 @@
+module: Main
+    function: main
+        parameter:
+        return_type: long
+        body:
+            declare n: long
+            n = 2147483647
+            n = n + 1
+            return n
+        end body
+    end function
+end module
\ No newline at end of file
diff --git a/playground/Demo9/Main.snow b/playground/Demo9/Main.snow
new file mode 100644
index 0000000..46749dd
--- /dev/null
+++ b/playground/Demo9/Main.snow
@@ -0,0 +1,31 @@
+module: Math
+    function: main
+        parameter:
+        return_type: int
+        body:
+            Math.factorial(6)
+            return 0
+        end body
+    end function
+
+    function: factorial
+        parameter:
+            declare n:int
+        return_type: int
+        body:
+            declare num1:int = 1
+            loop:
+                initializer:
+                    declare counter:int = 1
+                condition:
+                    counter <= n
+                update:
+                    counter = counter + 1
+                body:
+                    num1 = num1 * counter
+                end body
+            end loop
+            return num1
+        end body
+    end function
+end module
diff --git a/pom.xml b/pom.xml
index ba9e035..285cc54 100644
--- a/pom.xml
+++ b/pom.xml
@@ -7,9 +7,11 @@
 
     <groupId>org.jcnc.snow</groupId>
     <artifactId>Snow</artifactId>
-    <version>1.0-SNAPSHOT</version>
+    <version>0.4.0</version>
 
     <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
         <maven.compiler.source>24</maven.compiler.source>
         <maven.compiler.target>24</maven.compiler.target>
         <native.maven.plugin.version>0.10.5</native.maven.plugin.version>
@@ -17,17 +19,36 @@
 
     <!-- 通用编译 & 打包插件 -->
     <build>
+        <!-- 资源文件目录及占位符替换（resource filtering） -->
+        <resources>
+            <resource>
+                <!-- 指定资源文件所在目录 -->
+                <directory>src/main/resources</directory>
+                <!-- 开启资源文件中的占位符（如 ${project.version}）替换 -->
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+
         <plugins>
-            <!-- Java 编译插件 -->
+            <!--
+                Java 编译插件：
+                - 使用 Maven 自带的 maven-compiler-plugin 进行源码编译
+                - <fork>true</fork> 表示在单独的进程中执行 javac，提高兼容性
+            -->
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.12.1</version>
+                <version>3.14.0</version>
                 <configuration>
-                    <fork>true</fork>
+                    <release>24</release>
                 </configuration>
             </plugin>
-            <!-- Jar 打包插件 -->
+
+            <!--
+                Jar 打包插件：
+                - 使用 maven-jar-plugin 将编译产物打包成可执行 JAR
+                - 在 MANIFEST 中指定主类，支持命令行直接 java -jar 调用
+            -->
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-jar-plugin</artifactId>
@@ -35,8 +56,12 @@
                 <configuration>
                     <archive>
                         <manifest>
-                            <mainClass>org.jcnc.snow.compiler.cli.SnowCompiler</mainClass>
+                            <!-- 指定程序入口类，运行 java -jar 时会执行此类的 main 方法 -->
+                            <mainClass>org.jcnc.snow.cli.SnowCLI</mainClass>
+                            <!-- 将项目类路径添加到 MANIFEST Class-Path 中 -->
                             <addClasspath>true</addClasspath>
+                            <!-- 在 MANIFEST 中添加实现版本、实现供应商等默认条目 -->
+                            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                         </manifest>
                     </archive>
                 </configuration>
@@ -45,6 +70,11 @@
     </build>
 
     <profiles>
+        <!--
+            原生镜像构建：Linux 平台
+            - 使用 GraalVM 的 native-image 工具，生成静态链接的可执行文件
+            - 依赖 musl libc，需提前安装并配置 musl-gcc 工具链
+        -->
         <profile>
             <id>native-linux</id>
             <activation>
@@ -58,15 +88,19 @@
                         <groupId>org.graalvm.buildtools</groupId>
                         <artifactId>native-maven-plugin</artifactId>
                         <version>${native.maven.plugin.version}</version>
+                        <!-- 启用插件扩展，允许在 build 生命周期中无须额外配置 -->
                         <extensions>true</extensions>
                         <executions>
+                            <!-- 打包阶段生成原生可执行文件 -->
                             <execution>
                                 <id>build-native</id>
                                 <goals>
+                                    <!-- compile-no-fork 在当前 JVM 进程中执行 native-image -->
                                     <goal>compile-no-fork</goal>
                                 </goals>
                                 <phase>package</phase>
                             </execution>
+                            <!-- 测试阶段运行原生镜像的测试 -->
                             <execution>
                                 <id>test-native</id>
                                 <goals>
@@ -77,13 +111,17 @@
                         </executions>
                         <configuration>
                             <buildArgs>
+                                <!-- 静态链接 -->
                                 <buildArg>--static</buildArg>
+                                <!-- 指定 musl libc -->
                                 <buildArg>--libc=musl</buildArg>
+                                <!-- 输出构建报告 -->
                                 <buildArg>--emit build-report</buildArg>
+                                <!-- 优化级别 O2 -->
                                 <buildArg>-O2</buildArg>
                             </buildArgs>
                             <environment>
-                                <!-- 指定 musl-gcc 工具链 -->
+                                <!-- 指定使用 musl 工具链 -->
                                 <PATH>/opt/musl-1.2.5/bin:${env.PATH}</PATH>
                                 <C_INCLUDE_PATH>/opt/musl-1.2.5/include</C_INCLUDE_PATH>
                                 <LIBRARY_PATH>/opt/musl-1.2.5/lib</LIBRARY_PATH>
@@ -94,6 +132,11 @@
             </build>
         </profile>
 
+        <!--
+            原生镜像构建：Windows 平台
+            - 使用 GraalVM 的 native-image 工具，生成 Windows 可执行文件
+            - Windows 上不使用 musl，因此不配置静态链接
+        -->
         <profile>
             <id>native-windows</id>
             <activation>
@@ -109,6 +152,7 @@
                         <version>${native.maven.plugin.version}</version>
                         <extensions>true</extensions>
                         <executions>
+                            <!-- 打包阶段生成 Windows 可执行文件 -->
                             <execution>
                                 <id>build-native</id>
                                 <goals>
@@ -116,6 +160,7 @@
                                 </goals>
                                 <phase>package</phase>
                             </execution>
+                            <!-- 测试阶段运行原生镜像测试 -->
                             <execution>
                                 <id>test-native</id>
                                 <goals>
@@ -126,7 +171,9 @@
                         </executions>
                         <configuration>
                             <buildArgs>
+                                <!-- 输出构建报告 -->
                                 <buildArg>--emit build-report</buildArg>
+                                <!-- 优化级别 O2 -->
                                 <buildArg>-O2</buildArg>
                             </buildArgs>
                         </configuration>
@@ -135,4 +182,5 @@
             </build>
         </profile>
     </profiles>
+
 </project>
diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java
index 4759b93..3f8a7b3 100644
--- a/src/main/java/module-info.java
+++ b/src/main/java/module-info.java
@@ -1,4 +1,7 @@
+import org.jcnc.snow.cli.api.CLICommand;
+
 module org.jcnc.snow.compiler {
+    uses CLICommand;
     requires java.desktop;
     requires java.logging;
     exports org.jcnc.snow.compiler.ir.core;
diff --git a/src/main/java/org/jcnc/snow/cli/SnowCLI.java b/src/main/java/org/jcnc/snow/cli/SnowCLI.java
new file mode 100644
index 0000000..03a4391
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/cli/SnowCLI.java
@@ -0,0 +1,98 @@
+package org.jcnc.snow.cli;
+
+import org.jcnc.snow.cli.api.CLICommand;
+import org.jcnc.snow.cli.commands.*;
+import org.jcnc.snow.cli.utils.CLIUtils;
+import org.jcnc.snow.cli.utils.VersionUtils;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.function.Supplier;
+
+/**
+ * Snow 编程语言的命令行接口入口类。
+ * <p>
+ * 该类解析用户输入的命令行参数，调度相应的子命令（compile、run、version），
+ * 并处理全局帮助和版本信息输出。
+ * </p>
+ */
+public class SnowCLI {
+
+    /**
+     * Snow 编程语言的当前版本号，从资源文件中加载。
+     */
+    public static final String SNOW_VERSION = VersionUtils.loadVersion();
+
+    /**
+     * 可用子命令名称与对应命令处理器的映射表。
+     * 键为子命令名称（"compile", "run", "version"），
+     * 值为返回相应 {@link CLICommand} 实例的 Supplier。
+     */
+    private static final Map<String, Supplier<CLICommand>> COMMANDS = Map.of(
+            "generate", GenerateCommand::new,
+            "compile", CompileCommand::new,
+            "run", RunCommand::new,
+            "version", VersionCommand::new,
+            "init", InitCommand::new,
+            "build", BuildCommand::new,
+            "install", InstallCommand::new,
+            "publish", PublishCommand::new,
+            "clean", CleanCommand::new
+
+    );
+
+    /**
+     * 程序入口方法，解析并调度子命令。
+     * <p>
+     *
+     * @param args 命令行参数数组
+     *             无参数或首参数为帮助标志时，打印全局用法说明并退出
+     *             首参数为版本标志时，打印版本信息并退出
+     *             首参数为子命令名时，进一步解析该子命令的参数并执行
+     */
+    public static void main(String[] args) {
+        // 处理全局帮助
+        if (args.length == 0 || CLIUtils.GLOBAL_HELP_FLAGS.contains(args[0])) {
+            CLIUtils.printGeneralUsage(COMMANDS);
+            System.exit(0);
+        }
+
+        // 处理全局版本请求
+        if (CLIUtils.GLOBAL_VERSION_FLAGS.contains(args[0])) {
+            new VersionCommand().execute(new String[0]);
+            System.exit(0);
+        }
+
+        // 子命令名称
+        String cmdName = args[0];
+        Supplier<CLICommand> cmdSupplier = COMMANDS.get(cmdName);
+
+        // 未知子命令处理
+        if (cmdSupplier == null) {
+            System.err.println("Unknown command: " + cmdName);
+            CLIUtils.printGeneralUsage(COMMANDS);
+            System.exit(1);
+        }
+
+        // 创建对应子命令实例
+        CLICommand cmd = cmdSupplier.get();
+        // 提取子命令参数
+        String[] subArgs = Arrays.copyOfRange(args, 1, args.length);
+
+        // 如果子命令请求帮助，则打印该命令的用法说明并退出
+        if (subArgs.length > 0 && CLIUtils.GLOBAL_HELP_FLAGS.contains(subArgs[0])) {
+            cmd.printUsage();
+            System.exit(0);
+        }
+
+        // 执行子命令并根据返回的退出码退出
+        try {
+            int exitCode = cmd.execute(subArgs);
+            System.exit(exitCode);
+        } catch (Exception e) {
+            // 捕获命令执行过程中的异常并打印错误消息
+            System.err.println("Error: " + e.getMessage());
+            System.exit(1);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/cli/api/CLICommand.java b/src/main/java/org/jcnc/snow/cli/api/CLICommand.java
new file mode 100644
index 0000000..71e227e
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/cli/api/CLICommand.java
@@ -0,0 +1,47 @@
+package org.jcnc.snow.cli.api;
+
+import org.jcnc.snow.cli.SnowCLI;
+
+/**
+ * 所有 CLI 子命令（如 compile、run 等）都必须实现的命令接口。
+ * <p>
+ * 实现类应为无状态（stateless）、线程安全（thread-safe）。
+ * 可通过 {@link java.util.ServiceLoader ServiceLoader} 自动发现，
+ * 或直接在 {@link SnowCLI} 中注册。
+ * </p>
+ */
+public interface CLICommand {
+
+    /**
+     * 获取命令的名称（如 "compile"、"run"）。
+     *
+     * @return 命令名字符串
+     */
+    String name();
+
+    /**
+     * 获取命令的一行简介（用于 help 列表）。
+     *
+     * @return 命令描述字符串
+     */
+    String description();
+
+    /**
+     * 打印命令的专用 usage 信息（可选实现）。
+     * <p>
+     * 可覆盖此方法自定义帮助信息，默认无操作。
+     * </p>
+     */
+    default void printUsage() {
+        // 默认实现为空，可由子类覆盖
+    }
+
+    /**
+     * 执行命令逻辑。
+     *
+     * @param args 传递给子命令的参数（不含命令名本身）
+     * @return 进程退出码（0 为成功，非 0 为错误）
+     * @throws Exception 可抛出任意异常，框架会统一捕获和输出
+     */
+    int execute(String[] args) throws Exception;
+}
diff --git a/src/main/java/org/jcnc/snow/cli/commands/BuildCommand.java b/src/main/java/org/jcnc/snow/cli/commands/BuildCommand.java
new file mode 100644
index 0000000..17e1c0f
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/cli/commands/BuildCommand.java
@@ -0,0 +1,86 @@
+package org.jcnc.snow.cli.commands;
+
+import org.jcnc.snow.cli.api.CLICommand;
+import org.jcnc.snow.pkg.dsl.CloudDSLParser;
+import org.jcnc.snow.pkg.lifecycle.LifecycleManager;
+import org.jcnc.snow.pkg.lifecycle.LifecyclePhase;
+import org.jcnc.snow.pkg.model.Project;
+import org.jcnc.snow.pkg.resolver.DependencyResolver;
+import org.jcnc.snow.pkg.tasks.CompileTask;
+import org.jcnc.snow.pkg.tasks.PackageTask;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+/**
+ * CLI 命令：构建当前项目（包含依赖解析、编译、打包）。
+ * <p>
+ * 该命令会依次执行依赖解析、源码编译和产物打包阶段。
+ * </p>
+ *
+ * <pre>
+ * 用法示例：
+ * $ snow build
+ * </pre>
+ */
+public final class BuildCommand implements CLICommand {
+
+    /**
+     * 返回命令名称，用于 CLI 调用。
+     *
+     * @return 命令名称，如 "build"
+     */
+    @Override
+    public String name() {
+        return "build";
+    }
+
+    /**
+     * 返回命令简介，用于 CLI 帮助或命令列表展示。
+     *
+     * @return 命令描述字符串
+     */
+    @Override
+    public String description() {
+        return "Build the current project by resolving dependencies, compiling, and packaging in sequence.";
+    }
+
+    /**
+     * 打印命令用法信息。
+     */
+    @Override
+    public void printUsage() {
+        System.out.println("Usage: snow build ");
+    }
+
+    /**
+     * 执行项目构建流程。
+     * <ul>
+     *     <li>解析项目描述文件（project.cloud）</li>
+     *     <li>依赖解析（RESOLVE_DEPENDENCIES）</li>
+     *     <li>源码编译（COMPILE）</li>
+     *     <li>产物打包（PACKAGE）</li>
+     * </ul>
+     *
+     * @param args CLI 传入的参数数组
+     * @return 执行结果码（0 表示成功）
+     * @throws Exception 执行过程中出现错误时抛出
+     */
+    @Override
+    public int execute(String[] args) throws Exception {
+
+        Path dslFile = Paths.get("project.cloud");
+        Project project = CloudDSLParser.parse(dslFile);
+        DependencyResolver resolver = new DependencyResolver(Paths.get(System.getProperty("user.home"), ".snow", "cache"));
+        LifecycleManager lm = new LifecycleManager();
+
+        // 注册各阶段任务
+        lm.register(LifecyclePhase.RESOLVE_DEPENDENCIES, () -> resolver.resolve(project));
+        lm.register(LifecyclePhase.COMPILE, new CompileTask(project));
+        lm.register(LifecyclePhase.PACKAGE, new PackageTask(project));
+
+        lm.executeAll();
+
+        return 0;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/cli/commands/CleanCommand.java b/src/main/java/org/jcnc/snow/cli/commands/CleanCommand.java
new file mode 100644
index 0000000..0c65244
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/cli/commands/CleanCommand.java
@@ -0,0 +1,63 @@
+package org.jcnc.snow.cli.commands;
+
+import org.jcnc.snow.cli.api.CLICommand;
+import org.jcnc.snow.pkg.lifecycle.LifecycleManager;
+import org.jcnc.snow.pkg.lifecycle.LifecyclePhase;
+import org.jcnc.snow.pkg.tasks.CleanTask;
+
+/**
+ * CLI 命令：清理构建输出和本地缓存目录。
+ * <p>
+ * 用于清除项目生成的 build、dist 等中间产物，保持工作区整洁。
+ * </p>
+ *
+ * <pre>
+ * 用法示例：
+ * $ snow clean
+ * </pre>
+ */
+public final class CleanCommand implements CLICommand {
+
+    /**
+     * 返回命令名称，用于 CLI 调用。
+     *
+     * @return 命令名称，如 "clean"
+     */
+    @Override
+    public String name() {
+        return "clean";
+    }
+
+    /**
+     * 返回命令简介，用于 CLI 帮助或命令列表展示。
+     *
+     * @return 命令描述字符串
+     */
+    @Override
+    public String description() {
+        return "Clean build outputs and local cache, remove intermediate artifacts, and free disk space.";
+    }
+
+    /**
+     * 打印命令用法信息。
+     */
+    @Override
+    public void printUsage() {
+        System.out.println("Usage: snow clean ");
+    }
+
+    /**
+     * 执行清理任务。
+     *
+     * @param args CLI 传入的参数数组
+     * @return 执行结果码（0 表示成功）
+     * @throws Exception 执行过程中出现错误时抛出
+     */
+    @Override
+    public int execute(String[] args) throws Exception {
+        LifecycleManager lm = new LifecycleManager();
+        lm.register(LifecyclePhase.CLEAN, new CleanTask());
+        lm.executeAll();
+        return 0;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/cli/commands/CompileCommand.java b/src/main/java/org/jcnc/snow/cli/commands/CompileCommand.java
new file mode 100644
index 0000000..993e1cb
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/cli/commands/CompileCommand.java
@@ -0,0 +1,92 @@
+package org.jcnc.snow.cli.commands;
+
+import org.jcnc.snow.cli.api.CLICommand;
+import org.jcnc.snow.pkg.dsl.CloudDSLParser;
+import org.jcnc.snow.pkg.model.Project;
+import org.jcnc.snow.pkg.tasks.CompileTask;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * CLI 命令：编译当前项目。
+ *
+ * <p>工作模式说明：</p>
+ * <ul>
+ *   <li><strong>Cloud 模式</strong>
+ *       - 项目根目录存在 {@code project.cloud} 时触发；
+ *       - 解析 build 区块，自动推导源码目录与输出文件名；
+ *       - 用法：{@code snow compile [run]}</li>
+ *   <li><strong>Local 模式</strong>
+ *       - 未检测到 {@code project.cloud} 时回退；
+ *       - 保持向后兼容：{@code snow compile [run] [-o <name>] [-d <srcDir>] [file.snow …]}</li>
+ * </ul>
+ *
+ * <p>两种模式均将最终参数交由 {@link CompileTask} 处理。</p>
+ */
+public final class CompileCommand implements CLICommand {
+
+    @Override
+    public String name() {
+        return "compile";
+    }
+
+    @Override
+    public String description() {
+        return "Compile .snow source files into VM byte-code (.water).";
+    }
+
+    @Override
+    public void printUsage() {
+        System.out.println("Usage:");
+        System.out.println("  snow compile [run]                               (cloud mode, use project.cloud)");
+        System.out.println("  snow compile [run] [-o <name>] [-d <srcDir>] [file1.snow …]  (GOPATH mode)");
+    }
+
+    @Override
+    public int execute(String[] args) throws Exception {
+
+        Path dslFile = Paths.get("project.cloud");
+        Project project;
+        String[] compileArgs;
+
+        /* ---------- 1. Cloud 模式 ---------- */
+        if (Files.exists(dslFile)) {
+            project = CloudDSLParser.parse(dslFile);
+
+            List<String> argList = new ArrayList<>();
+
+            // 保留用户在 cloud 模式下传入的 “run” 标志
+            for (String a : args) {
+                if ("run".equals(a)) {
+                    argList.add("run");
+                }
+            }
+
+            /* 源码目录：build.srcDir -> 默认 src */
+            String srcDir = project.getBuild().get("srcDir", "src");
+            argList.add("-d");
+            argList.add(srcDir);
+
+            /* 输出名称：build.output -> fallback to artifact */
+            String output = project.getBuild().get("output", project.getArtifact());
+            argList.add("-o");
+            argList.add(output);
+
+            compileArgs = argList.toArray(new String[0]);
+        }
+        /* ---------- 2. Local 模式 ---------- */
+        else {
+            project = Project.fromFlatMap(Collections.emptyMap()); // 占位项目，保持接口统一
+            compileArgs = args;                                    // 透传原始 CLI 参数
+        }
+
+        // 委托给 CompileTask 完成实际编译/运行
+        new CompileTask(project, compileArgs).run();
+        return 0;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/cli/commands/GenerateCommand.java b/src/main/java/org/jcnc/snow/cli/commands/GenerateCommand.java
new file mode 100644
index 0000000..b83a28d
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/cli/commands/GenerateCommand.java
@@ -0,0 +1,87 @@
+package org.jcnc.snow.cli.commands;
+
+import org.jcnc.snow.cli.api.CLICommand;
+import org.jcnc.snow.pkg.dsl.CloudDSLParser;
+import org.jcnc.snow.pkg.lifecycle.LifecycleManager;
+import org.jcnc.snow.pkg.lifecycle.LifecyclePhase;
+import org.jcnc.snow.pkg.model.Project;
+import org.jcnc.snow.pkg.tasks.GenerateTask;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+/**
+ * CLI 命令：根据 project.cloud 生成项目目录结构。
+ * <p>
+ * 负责解析云项目描述文件，并通过 {@link GenerateTask}
+ * 在 INIT 生命周期阶段内生成基础目录结构。
+ * </p>
+ *
+ * <pre>
+ * 用法示例：
+ * $ snow generate
+ * </pre>
+ *
+ * <p>
+ * 注意事项：
+ * - 若当前目录不存在 project.cloud，则提示用户先执行 `snow init`。
+ * - 执行成功后，会输出已创建的目录/文件。
+ * </p>
+ */
+public final class GenerateCommand implements CLICommand {
+
+    /**
+     * 返回命令名称，用于 CLI 调用。
+     *
+     * @return 命令名称，如 "generate"
+     */
+    @Override
+    public String name() {
+        return "generate";
+    }
+
+    /**
+     * 返回命令简介，用于 CLI 帮助或命令列表展示。
+     *
+     * @return 命令描述字符串
+     */
+    @Override
+    public String description() {
+        return "Generate project directory structure based on project.cloud.";
+    }
+
+    /**
+     * 打印命令用法信息。
+     */
+    @Override
+    public void printUsage() {
+        System.out.println("Usage: snow generate");
+    }
+
+    /**
+     * 执行生成任务。
+     *
+     * @param args CLI 传入的参数数组（此命令不接受参数）
+     * @return 执行结果码（0 表示成功，1 表示 project.cloud 缺失）
+     * @throws Exception 执行过程中出现错误时抛出
+     */
+    @Override
+    public int execute(String[] args) throws Exception {
+        Path dsl = Paths.get("project.cloud");
+        if (Files.notExists(dsl)) {
+            System.err.println("project.cloud not found. Please run `snow init` first.");
+            return 1;
+        }
+
+        /* 1. 解析 DSL */
+        Project project = CloudDSLParser.parse(dsl);
+
+        /* 2. 执行生成任务 —— 复用 Lifecycle INIT 阶段 */
+        LifecycleManager lm = new LifecycleManager();
+        lm.register(LifecyclePhase.INIT, new GenerateTask(project));
+        lm.executeAll();
+
+        return 0;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/cli/commands/InitCommand.java b/src/main/java/org/jcnc/snow/cli/commands/InitCommand.java
new file mode 100644
index 0000000..d9cbf92
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/cli/commands/InitCommand.java
@@ -0,0 +1,71 @@
+package org.jcnc.snow.cli.commands;
+
+import org.jcnc.snow.cli.api.CLICommand;
+import org.jcnc.snow.cli.utils.ProjectCloudExample;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+/**
+ * CLI 命令：初始化项目配置文件。
+ * <p>
+ * 用于快速生成 DSL 配置文件（project.cloud）。
+ * </p>
+ *
+ * <pre>
+ * 用法示例：
+ * $ snow init
+ * </pre>
+ */
+public final class InitCommand implements CLICommand {
+
+    /**
+     * 返回命令名称，用于 CLI 调用。
+     *
+     * @return 命令名称，如 "init"
+     */
+    @Override
+    public String name() {
+        return "init";
+    }
+
+    /**
+     * 返回命令简介，用于 CLI 帮助或命令列表展示。
+     *
+     * @return 命令描述字符串
+     */
+    @Override
+    public String description() {
+        return "Initialize a new project with project.cloud file.";
+    }
+
+    /**
+     * 打印命令用法信息。
+     */
+    @Override
+    public void printUsage() {
+        System.out.println("Usage: snow init");
+    }
+
+    /**
+     * 执行项目初始化流程，仅创建 DSL 配置文件。
+     *
+     * @param args CLI 传入的参数数组
+     * @return 执行结果码（0 表示成功）
+     * @throws Exception 文件创建过程中出现错误时抛出
+     */
+    @Override
+    public int execute(String[] args) throws Exception {
+        // 仅生成 `.cloud` 文件
+        Path dir = Paths.get(".").toAbsolutePath();
+        Path dsl = dir.resolve("project.cloud");
+        if (Files.notExists(dsl)) {
+            Files.writeString(dsl, ProjectCloudExample.getProjectCloud());
+            System.out.println("[init] created " + dsl);
+        } else {
+            System.out.println("[init] project.cloud already exists");
+        }
+        return 0;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/cli/commands/InstallCommand.java b/src/main/java/org/jcnc/snow/cli/commands/InstallCommand.java
new file mode 100644
index 0000000..6199602
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/cli/commands/InstallCommand.java
@@ -0,0 +1,65 @@
+package org.jcnc.snow.cli.commands;
+
+import org.jcnc.snow.cli.api.CLICommand;
+import org.jcnc.snow.pkg.dsl.CloudDSLParser;
+import org.jcnc.snow.pkg.model.Project;
+import org.jcnc.snow.pkg.resolver.DependencyResolver;
+
+import java.nio.file.Paths;
+
+/**
+ * CLI 命令：解析并下载项目依赖到本地缓存。
+ * <p>
+ * 适用于离线使用和依赖预热场景，会自动读取项目描述文件并处理依赖缓存。
+ * </p>
+ *
+ * <pre>
+ * 用法示例：
+ * $ snow install
+ * </pre>
+ */
+public final class InstallCommand implements CLICommand {
+
+    /**
+     * 返回命令名称，用于 CLI 调用。
+     *
+     * @return 命令名称，如 "install"
+     */
+    @Override
+    public String name() {
+        return "install";
+    }
+
+    /**
+     * 返回命令简介，用于 CLI 帮助或命令列表展示。
+     *
+     * @return 命令描述字符串
+     */
+    @Override
+    public String description() {
+        return "Resolve and download project dependencies to local cache for offline development or faster builds.";
+    }
+
+    /**
+     * 打印命令用法信息。
+     */
+    @Override
+    public void printUsage() {
+        System.out.println("Usage: snow install ");
+    }
+
+    /**
+     * 执行依赖解析和下载任务。
+     *
+     * @param args CLI 传入的参数数组
+     * @return 执行结果码（0 表示成功）
+     * @throws Exception 解析或下载依赖过程中出现错误时抛出
+     */
+    @Override
+    public int execute(String[] args) throws Exception {
+        Project project = CloudDSLParser.parse(Paths.get("project.cloud"));
+        DependencyResolver resolver = new DependencyResolver(Paths.get(System.getProperty("user.home"), ".snow", "cache"));
+        resolver.resolve(project);
+        return 0;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/cli/commands/PublishCommand.java b/src/main/java/org/jcnc/snow/cli/commands/PublishCommand.java
new file mode 100644
index 0000000..658e799
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/cli/commands/PublishCommand.java
@@ -0,0 +1,74 @@
+package org.jcnc.snow.cli.commands;
+
+import org.jcnc.snow.cli.api.CLICommand;
+import org.jcnc.snow.pkg.dsl.CloudDSLParser;
+import org.jcnc.snow.pkg.lifecycle.LifecycleManager;
+import org.jcnc.snow.pkg.lifecycle.LifecyclePhase;
+import org.jcnc.snow.pkg.model.Project;
+import org.jcnc.snow.pkg.tasks.PublishTask;
+
+import java.nio.file.Paths;
+
+/**
+ * CLI 命令：将已构建的项目包发布到远程仓库。
+ * <p>
+ * 用于持续集成、交付或分发场景。
+ * 支持自动读取 DSL 项目描述文件，并注册和执行发布生命周期阶段的任务。
+ * </p>
+ *
+ * <pre>
+ * 用法示例：
+ * $ snow publish
+ * </pre>
+ */
+public final class PublishCommand implements CLICommand {
+
+    /**
+     * 返回该命令的名称（用于 CLI 调用）。
+     *
+     * @return 命令名称字符串，如 "publish"
+     */
+    @Override
+    public String name() {
+        return "publish";
+    }
+
+    /**
+     * 返回命令简介，用于 CLI 帮助或命令列表展示。
+     *
+     * @return 命令描述字符串
+     */
+    @Override
+    public String description() {
+        return "Publish the built package to a remote repository, suitable for continuous integration, delivery, or project distribution.";
+    }
+
+    /**
+     * 打印命令用法信息，供终端用户参考。
+     */
+    @Override
+    public void printUsage() {
+        System.out.println("Usage: snow publish ");
+    }
+
+    /**
+     * 执行发布命令。
+     * <ul>
+     *   <li>解析项目描述文件（如 project.cloud）</li>
+     *   <li>注册并执行 PUBLISH 阶段的任务</li>
+     * </ul>
+     *
+     * @param args CLI 传入的参数数组
+     * @return 执行结果码（0表示成功）
+     * @throws Exception 执行过程中出现错误时抛出
+     */
+    @Override
+    public int execute(String[] args) throws Exception {
+        Project project = CloudDSLParser.parse(Paths.get("project.cloud"));
+        LifecycleManager lm = new LifecycleManager();
+        lm.register(LifecyclePhase.PUBLISH, new PublishTask(project));
+        lm.executeAll();
+
+        return 0;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/cli/commands/RunCommand.java b/src/main/java/org/jcnc/snow/cli/commands/RunCommand.java
new file mode 100644
index 0000000..0aeffe6
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/cli/commands/RunCommand.java
@@ -0,0 +1,66 @@
+package org.jcnc.snow.cli.commands;
+
+import org.jcnc.snow.cli.api.CLICommand;
+import org.jcnc.snow.pkg.tasks.RunTask;
+
+/**
+ * CLI 命令：运行已编译的 VM 字节码文件（.water）。
+ * <p>
+ * 仅解析参数并委托给 {@link RunTask}，
+ * 将 VM 运行逻辑下沉至 pkg 层，保持 CLI 无状态、薄封装。
+ * </p>
+ *
+ * <pre>
+ * 用法示例：
+ * $ snow run main.water
+ * </pre>
+ */
+public final class RunCommand implements CLICommand {
+
+    /**
+     * 返回命令名称，用于 CLI 调用。
+     *
+     * @return 命令名称，如 "run"
+     */
+    @Override
+    public String name() {
+        return "run";
+    }
+
+    /**
+     * 返回命令简介，用于 CLI 帮助或命令列表展示。
+     *
+     * @return 命令描述字符串
+     */
+    @Override
+    public String description() {
+        return "Run the compiled VM bytecode file (.water)";
+    }
+
+    /**
+     * 执行运行任务。
+     *
+     * @param args CLI 传入的参数数组
+     * @return 执行结果码（0 表示成功，非 0 表示失败）
+     * @throws Exception 执行过程中出现错误时抛出
+     */
+    @Override
+    public int execute(String[] args) throws Exception {
+        if (args.length == 0) {
+            printUsage();
+            return 1;
+        }
+        // 委托给 RunTask 执行字节码运行逻辑
+        new RunTask(args).run();
+        return 0;
+    }
+
+    /**
+     * 打印命令用法信息。
+     */
+    @Override
+    public void printUsage() {
+        System.out.println("Usage:");
+        System.out.println("  snow run <program.water>");
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/cli/commands/VersionCommand.java b/src/main/java/org/jcnc/snow/cli/commands/VersionCommand.java
new file mode 100644
index 0000000..d2989b5
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/cli/commands/VersionCommand.java
@@ -0,0 +1,59 @@
+package org.jcnc.snow.cli.commands;
+
+import org.jcnc.snow.cli.SnowCLI;
+import org.jcnc.snow.cli.api.CLICommand;
+
+/**
+ * CLI 子命令：输出当前 Snow 工具的版本号。
+ * <p>
+ * 用于显示当前 CLI 工具版本，便于诊断、升级、兼容性确认等场景。
+ * </p>
+ *
+ * <pre>
+ * 用法示例：
+ * $ snow version
+ * </pre>
+ */
+public final class VersionCommand implements CLICommand {
+
+    /**
+     * 返回命令名，用于 CLI 调用。
+     *
+     * @return 命令名称字符串（"version"）
+     */
+    @Override
+    public String name() {
+        return "version";
+    }
+
+    /**
+     * 返回命令简介，用于 CLI 帮助或命令列表展示。
+     *
+     * @return 命令描述字符串
+     */
+    @Override
+    public String description() {
+        return "Print snow version.";
+    }
+
+    /**
+     * 打印该命令的用法说明。
+     */
+    @Override
+    public void printUsage() {
+        System.out.println("Usage:");
+        System.out.println("  snow version");
+    }
+
+    /**
+     * 执行 version 命令，输出当前 Snow 的版本号。
+     *
+     * @param args 命令参数，此命令不接受额外参数
+     * @return 0 表示成功执行
+     */
+    @Override
+    public int execute(String[] args) {
+        System.out.println("snow version \"" + SnowCLI.SNOW_VERSION + "\"");
+        return 0;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/cli/utils/CLIUtils.java b/src/main/java/org/jcnc/snow/cli/utils/CLIUtils.java
new file mode 100644
index 0000000..ca36951
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/cli/utils/CLIUtils.java
@@ -0,0 +1,70 @@
+package org.jcnc.snow.cli.utils;
+
+import org.jcnc.snow.cli.api.CLICommand;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Supplier;
+
+/**
+ * 命令行界面通用工具类，提供全局帮助和版本标志、全局选项定义，以及打印通用用法的方法。
+ */
+public class CLIUtils {
+
+    /**
+     * 全局帮助标志集合，支持 "help"、"-h"、"--help"。
+     */
+    public static final Set<String> GLOBAL_HELP_FLAGS = Set.of(
+            "help", "-h", "--help"
+    );
+
+    /**
+     * 全局版本标志集合，支持 "-v"、"--version"。
+     */
+    public static final Set<String> GLOBAL_VERSION_FLAGS = Set.of(
+            "-v", "--version"
+    );
+
+    /**
+     * 全局选项列表，包括帮助和版本选项的描述。
+     */
+    public static final List<Option> GLOBAL_OPTIONS = List.of(
+            new Option(List.of("-h", "--help"), "Show this help message and exit"),
+            new Option(List.of("-v", "--version"), "Print snow programming language version and exit")
+    );
+
+    /**
+     * 打印命令行工具的通用用法说明。
+     * <p>
+     *
+     * @param commands 可用子命令名称到命令处理器的映射，用于列出所有子命令及其描述
+     */
+    public static void printGeneralUsage(Map<String, Supplier<CLICommand>> commands) {
+        System.out.println("Usage:");
+        System.out.println("  snow [OPTIONS] <command>");
+        System.out.println();
+        System.out.println("Options:");
+        for (Option opt : GLOBAL_OPTIONS) {
+            String flags = String.join(", ", opt.flags());
+            System.out.printf("  %-15s %s%n", flags, opt.description());
+        }
+        System.out.println();
+        System.out.println("Commands:");
+        commands.forEach((name, supplier) -> {
+            CLICommand c = supplier.get();
+            System.out.printf("  %-10s %s%n", name, c.description());
+        });
+        System.out.println();
+        System.out.println("Use \"snow <command> --help\" for command-specific options.");
+    }
+
+    /**
+     * 全局选项的数据结构，包含选项标志和描述。
+     *
+     * @param flags       选项标志列表，例如 ["-h", "--help"]
+     * @param description 选项功能描述
+     */
+    public record Option(List<String> flags, String description) {
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/cli/utils/ProjectCloudExample.java b/src/main/java/org/jcnc/snow/cli/utils/ProjectCloudExample.java
new file mode 100644
index 0000000..b51e126
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/cli/utils/ProjectCloudExample.java
@@ -0,0 +1,31 @@
+package org.jcnc.snow.cli.utils;
+
+public class ProjectCloudExample {
+    /**
+     * 工具类构造方法，禁止实例化。
+     */
+    private ProjectCloudExample() {
+        // 工具类不允许实例化
+    }
+
+    /**
+     * 获取 main.snow 示例模块的内容字符串。
+     *
+     * @return main.snow 示例模块的完整代码
+     */
+    public static String getProjectCloud() {
+        return """
+                # Generated by snow init
+                project {
+                    group    = "com.example"
+                    artifact = "demo-app"
+                    version  = "0.0.1-SNAPSHOT"
+                }
+                
+                build {
+                    srcDir = "src"
+                    output = "build/demo-app"
+                }
+                """;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/cli/utils/VersionUtils.java b/src/main/java/org/jcnc/snow/cli/utils/VersionUtils.java
new file mode 100644
index 0000000..5503565
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/cli/utils/VersionUtils.java
@@ -0,0 +1,41 @@
+package org.jcnc.snow.cli.utils;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UncheckedIOException;
+import java.util.Properties;
+
+/**
+ * 版本工具类，用于加载资源文件中的 Snow 编程语言版本信息。
+ * <p>
+ * 从 classpath 路径下的 version.properties 文件中读取属性 "snow.version"，
+ * 并返回对应的版本号字符串。
+ * </p>
+ */
+public class VersionUtils {
+
+    /**
+     * 资源文件路径常量，指向 classpath 根目录下的 version.properties 文件。
+     */
+    private static final String PROPERTIES_PATH = "/version.properties";
+
+    /**
+     * 加载并返回 Snow 编程语言的版本号。
+     * <p>
+     * 通过 Class.getResourceAsStream 方法读取 version.properties 文件，
+     * 使用 {@link Properties} 类解析并获取 key 为 "snow.version" 的值。
+     * </p>
+     *
+     * @return 从 version.properties 中读取的版本号（如 "1.0.0"）
+     * @throws UncheckedIOException 如果读取或解析配置文件时发生 I/O 错误
+     */
+    public static String loadVersion() {
+        try (InputStream in = VersionUtils.class.getResourceAsStream(PROPERTIES_PATH)) {
+            Properties properties = new Properties();
+            properties.load(in);
+            return properties.getProperty("snow.version");
+        } catch (IOException e) {
+            throw new UncheckedIOException("Failed to load version from " + PROPERTIES_PATH, e);
+        }
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/compiler/backend/generator/BinaryOpGenerator.java b/src/main/java/org/jcnc/snow/compiler/backend/generator/BinaryOpGenerator.java
index 91a4d91..0d0a983 100644
--- a/src/main/java/org/jcnc/snow/compiler/backend/generator/BinaryOpGenerator.java
+++ b/src/main/java/org/jcnc/snow/compiler/backend/generator/BinaryOpGenerator.java
@@ -2,8 +2,8 @@ package org.jcnc.snow.compiler.backend.generator;
 
 import org.jcnc.snow.compiler.backend.builder.VMProgramBuilder;
 import org.jcnc.snow.compiler.backend.core.InstructionGenerator;
-import org.jcnc.snow.compiler.backend.util.IROpCodeMapper;
-import org.jcnc.snow.compiler.backend.util.OpHelper;
+import org.jcnc.snow.compiler.backend.utils.IROpCodeMapper;
+import org.jcnc.snow.compiler.backend.utils.OpHelper;
 import org.jcnc.snow.compiler.ir.core.IRValue;
 import org.jcnc.snow.compiler.ir.instruction.BinaryOperationInstruction;
 import org.jcnc.snow.compiler.ir.value.IRConstant;
diff --git a/src/main/java/org/jcnc/snow/compiler/backend/generator/CallGenerator.java b/src/main/java/org/jcnc/snow/compiler/backend/generator/CallGenerator.java
index ff6961b..d3a7b80 100644
--- a/src/main/java/org/jcnc/snow/compiler/backend/generator/CallGenerator.java
+++ b/src/main/java/org/jcnc/snow/compiler/backend/generator/CallGenerator.java
@@ -2,7 +2,7 @@ package org.jcnc.snow.compiler.backend.generator;
 
 import org.jcnc.snow.compiler.backend.builder.VMProgramBuilder;
 import org.jcnc.snow.compiler.backend.core.InstructionGenerator;
-import org.jcnc.snow.compiler.backend.util.OpHelper;
+import org.jcnc.snow.compiler.backend.utils.OpHelper;
 import org.jcnc.snow.compiler.ir.instruction.CallInstruction;
 import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 
@@ -62,7 +62,7 @@ public class CallGenerator implements InstructionGenerator<CallInstruction> {
             char t = out.getSlotType(slotId);                  // 获取参数类型
             if (t == '\0') t = 'I';                            // 类型未知时默认整型
             // 生成类型相关的加载指令，如 I_LOAD、F_LOAD 等
-            out.emit(OpHelper.opcode(String.valueOf(t) + "_LOAD") + " " + slotId);
+            out.emit(OpHelper.opcode(t + "_LOAD") + " " + slotId);
         }
 
         // —— 3. 生成 CALL 调用指令 ——
@@ -70,7 +70,7 @@ public class CallGenerator implements InstructionGenerator<CallInstruction> {
 
         // —— 4. 将返回值存入目标槽，并记录槽的类型 ——
         int destSlot = slotMap.get(ins.getDest()); // 目标寄存器槽
-        out.emit(OpHelper.opcode(String.valueOf(retType) + "_STORE") + " " + destSlot);
+        out.emit(OpHelper.opcode(retType + "_STORE") + " " + destSlot);
         out.setSlotType(destSlot, retType);        // 标记返回值类型
     }
 }
diff --git a/src/main/java/org/jcnc/snow/compiler/backend/generator/CmpJumpGenerator.java b/src/main/java/org/jcnc/snow/compiler/backend/generator/CmpJumpGenerator.java
index 5f15051..57437b4 100644
--- a/src/main/java/org/jcnc/snow/compiler/backend/generator/CmpJumpGenerator.java
+++ b/src/main/java/org/jcnc/snow/compiler/backend/generator/CmpJumpGenerator.java
@@ -1,7 +1,7 @@
 package org.jcnc.snow.compiler.backend.generator;
 
-import org.jcnc.snow.compiler.backend.util.IROpCodeMapper;
-import org.jcnc.snow.compiler.backend.util.OpHelper;
+import org.jcnc.snow.compiler.backend.utils.IROpCodeMapper;
+import org.jcnc.snow.compiler.backend.utils.OpHelper;
 import org.jcnc.snow.compiler.backend.builder.VMProgramBuilder;
 import org.jcnc.snow.compiler.backend.core.InstructionGenerator;
 import org.jcnc.snow.compiler.ir.instruction.IRCompareJumpInstruction;
@@ -10,18 +10,26 @@ import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 import java.util.Map;
 
 /**
- * 条件比较跳转指令生成器
+ * <b>条件比较跳转指令生成器</b>
  * <p>
- * 该类实现了 {@link InstructionGenerator} 接口，用于将 IR 中的条件比较跳转指令
- * 转换为虚拟机可执行的指令序列。主要流程是先将比较操作数加载到虚拟机栈中，生成比较操作码，
- * 并发出跳转到目标标签的指令。
+ * 该类实现了 {@link InstructionGenerator} 接口，
+ * 负责将 IR 中的 {@link IRCompareJumpInstruction}（条件比较并跳转指令）
+ * 转换为目标虚拟机（VM）可执行的指令序列。
+ * </p>
+ *
+ * <b>主要功能</b>
+ * <ul>
+ *     <li>根据 IR 比较指令左右操作数的类型，自动进行类型提升与转换</li>
+ *     <li>生成相应的 VM 加载、类型转换、比较与跳转指令</li>
+ *     <li>保证指令的类型前缀与操作数类型一致，提升兼容性与正确性</li>
+ * </ul>
  */
 public class CmpJumpGenerator implements InstructionGenerator<IRCompareJumpInstruction> {
 
     /**
-     * 返回该生成器所支持的指令类型。
+     * 返回本生成器支持的 IR 指令类型。
      *
-     * @return {@link IRCompareJumpInstruction} 的类对象
+     * @return IRCompareJumpInstruction 的类对象
      */
     @Override
     public Class<IRCompareJumpInstruction> supportedClass() {
@@ -29,29 +37,138 @@ public class CmpJumpGenerator implements InstructionGenerator<IRCompareJumpInstr
     }
 
     /**
-     * 生成条件比较跳转相关的虚拟机指令。
+     * <b>类型宽度优先级</b>：D > F > L > I > S > B
+     * <ul>
+     *     <li>D（double）：6</li>
+     *     <li>F（float）：5</li>
+     *     <li>L（long）：4</li>
+     *     <li>I（int）：3</li>
+     *     <li>S（short）：2</li>
+     *     <li>B（byte）：1</li>
+     *     <li>未识别类型：0</li>
+     * </ul>
      *
-     * @param ins        需要生成的条件比较跳转中间指令（IR）
-     * @param out        虚拟机程序构建器，用于输出生成的指令
-     * @param slotMap    虚拟寄存器到实际槽（slot）编号的映射表
-     * @param currentFn  当前处理的函数名（可用于调试或作用域标识）
+     * @param p 类型标记字符
+     * @return 优先级数值（越大类型越宽）
+     */
+    private static int rank(char p) {
+        return switch (p) {
+            case 'D' -> 6;
+            case 'F' -> 5;
+            case 'L' -> 4;
+            case 'I' -> 3;
+            case 'S' -> 2;
+            case 'B' -> 1;
+            default  -> 0;
+        };
+    }
+
+    /**
+     * 返回更“宽”的公共类型（即优先级高的类型）。
+     *
+     * @param a 类型标记字符 1
+     * @param b 类型标记字符 2
+     * @return 宽度更高的类型标记字符
+     */
+    private static char promote(char a, char b) {
+        return rank(a) >= rank(b) ? a : b;
+    }
+
+    /**
+     * 单字符类型标记转字符串。
+     *
+     * @param p 类型标记字符
+     * @return 类型字符串
+     */
+    private static String str(char p) {
+        return String.valueOf(p);
+    }
+
+    /**
+     * 获取 {@code from → to} 的类型转换指令名（如不需转换则返回 {@code null}）。
+     * <p>
+     * 仅覆盖目前常见的整数与浮点类型提升与转换，后续有新类型可补充。
+     * </p>
+     *
+     * @param from 源类型标记字符
+     * @param to   目标类型标记字符
+     * @return 转换指令名，如“L2I”；无转换返回 {@code null}
+     */
+    private static String convert(char from, char to) {
+        if (from == to) return null;
+        return switch ("" + from + to) {
+            case "IL" -> "I2L";
+            case "ID" -> "I2D";
+            case "IF" -> "I2F";
+            case "LI" -> "L2I";
+            case "LD" -> "L2D";
+            case "LF" -> "L2F";
+            case "FI" -> "F2I";
+            case "FL" -> "F2L";
+            case "FD" -> "F2D";
+            case "DI" -> "D2I";
+            case "DL" -> "D2L";
+            case "DF" -> "D2F";
+            case "SI" -> "S2I";
+            case "BI" -> "B2I";
+            default   -> null;
+        };
+    }
+
+    /**
+     * 生成 IR 条件比较跳转指令的 VM 指令序列。
+     * <ol>
+     *     <li>确定左右操作数的槽位及静态类型</li>
+     *     <li>加载并按需类型提升转换</li>
+     *     <li>根据公共类型调整比较指令前缀</li>
+     *     <li>发出最终比较和跳转指令</li>
+     * </ol>
+     *
+     * @param ins       IR 条件比较跳转指令
+     * @param out       VMProgramBuilder：用于发出 VM 指令
+     * @param slotMap   虚拟寄存器到 VM 槽位的映射表
+     * @param currentFn 当前处理的函数名（调试用，当前未使用）
      */
     @Override
-    public void generate(IRCompareJumpInstruction ins,
-                         VMProgramBuilder out,
-                         Map<IRVirtualRegister, Integer> slotMap,
-                         String currentFn) {
-        // 获取左操作数所在的寄存器槽编号
-        int leftSlot = slotMap.get(ins.left());
-        // 获取右操作数所在的寄存器槽编号
-        int rightSlot = slotMap.get(ins.right());
-        // 加载左操作数到虚拟机栈
-        out.emit(OpHelper.opcode("I_LOAD") + " " + leftSlot);
-        // 加载右操作数到虚拟机栈
-        out.emit(OpHelper.opcode("I_LOAD") + " " + rightSlot);
-        // 获取与当前比较操作对应的虚拟机操作码
+    public void generate(IRCompareJumpInstruction  ins,
+                         VMProgramBuilder          out,
+                         Map<IRVirtualRegister,Integer> slotMap,
+                         String                    currentFn) {
+
+        // 1. 获取左右操作数的槽位与静态类型
+        int  leftSlot  = slotMap.get(ins.left());
+        int  rightSlot = slotMap.get(ins.right());
+        char lType     = out.getSlotType(leftSlot);   // 若未登记则默认 'I'
+        char rType     = out.getSlotType(rightSlot);
+        char tType     = promote(lType, rType);        // 公共类型提升
+
+        // 2. 加载左右操作数并按需类型转换
+        // 左操作数
+        out.emit(OpHelper.opcode(str(lType) + "_LOAD") + " " + leftSlot);
+        String cvt = convert(lType, tType);
+        if (cvt != null) {
+            out.emit(OpHelper.opcode(cvt));
+        }
+
+        // 右操作数
+        out.emit(OpHelper.opcode(str(rType) + "_LOAD") + " " + rightSlot);
+        cvt = convert(rType, tType);
+        if (cvt != null) {
+            out.emit(OpHelper.opcode(cvt));
+        }
+
+        // 3. 选择正确的比较指令前缀
         String cmpOp = IROpCodeMapper.toVMOp(ins.op());
-        // 生成分支跳转指令，如果比较成立则跳转到目标标签
+        /*
+         * 指令前缀（如 int 类型要用 IC_*, long 类型要用 LC_*）
+         */
+        if (tType == 'I' && cmpOp.startsWith("LC_")) {
+            cmpOp = "IC_" + cmpOp.substring(3);
+        } else if (tType == 'L' && cmpOp.startsWith("IC_")) {
+            cmpOp = "LC_" + cmpOp.substring(3);
+        }
+
+        // 4. 发出比较与跳转指令
         out.emitBranch(OpHelper.opcode(cmpOp), ins.label());
     }
 }
diff --git a/src/main/java/org/jcnc/snow/compiler/backend/generator/InstructionGeneratorProvider.java b/src/main/java/org/jcnc/snow/compiler/backend/generator/InstructionGeneratorProvider.java
new file mode 100644
index 0000000..2b2517d
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/compiler/backend/generator/InstructionGeneratorProvider.java
@@ -0,0 +1,42 @@
+package org.jcnc.snow.compiler.backend.generator;
+
+import org.jcnc.snow.compiler.backend.core.InstructionGenerator;
+import org.jcnc.snow.compiler.ir.core.IRInstruction;
+
+import java.util.List;
+
+/**
+ * 指令生成器集中注册表。
+ *
+ * <p>本类在类加载阶段即完成所有后端 {@link InstructionGenerator} 实例
+ * 的创建，并以不可变列表形式对外暴露。
+ */
+public final class InstructionGeneratorProvider {
+
+    /** 工具类禁止实例化。 */
+    private InstructionGeneratorProvider() { /* no-instance */ }
+
+    /** 缺省指令生成器列表（不可修改，顺序即执行顺序）。 */
+    private static final List<InstructionGenerator<? extends IRInstruction>> DEFAULT =
+            List.of(
+                    new LoadConstGenerator(),  // 常量加载
+                    new BinaryOpGenerator(),   // 二元运算
+                    new UnaryOpGenerator(),    // 一元运算
+                    new CallGenerator(),       // 函数调用
+                    new ReturnGenerator(),     // 函数返回
+                    new LabelGenerator(),      // 标签定义
+                    new JumpGenerator(),       // 无条件跳转
+                    new CmpJumpGenerator()     // 条件跳转
+            );
+
+    /**
+     * 返回生产环境使用的缺省指令生成器列表。
+     * 该列表为不可变集合，如尝试修改将抛出
+     * {@link UnsupportedOperationException}。
+     *
+     * @return 不可变的 {@code List} 实例
+     */
+    public static List<InstructionGenerator<? extends IRInstruction>> defaultGenerators() {
+        return DEFAULT;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/compiler/backend/generator/JumpGenerator.java b/src/main/java/org/jcnc/snow/compiler/backend/generator/JumpGenerator.java
index 85d2907..c8426b3 100644
--- a/src/main/java/org/jcnc/snow/compiler/backend/generator/JumpGenerator.java
+++ b/src/main/java/org/jcnc/snow/compiler/backend/generator/JumpGenerator.java
@@ -1,6 +1,6 @@
 package org.jcnc.snow.compiler.backend.generator;
 
-import org.jcnc.snow.compiler.backend.util.OpHelper;
+import org.jcnc.snow.compiler.backend.utils.OpHelper;
 import org.jcnc.snow.compiler.backend.builder.VMProgramBuilder;
 import org.jcnc.snow.compiler.backend.core.InstructionGenerator;
 import org.jcnc.snow.compiler.ir.instruction.IRJumpInstruction;
diff --git a/src/main/java/org/jcnc/snow/compiler/backend/generator/LoadConstGenerator.java b/src/main/java/org/jcnc/snow/compiler/backend/generator/LoadConstGenerator.java
index 9e75f22..760422a 100644
--- a/src/main/java/org/jcnc/snow/compiler/backend/generator/LoadConstGenerator.java
+++ b/src/main/java/org/jcnc/snow/compiler/backend/generator/LoadConstGenerator.java
@@ -2,7 +2,7 @@ package org.jcnc.snow.compiler.backend.generator;
 
 import org.jcnc.snow.compiler.backend.builder.VMProgramBuilder;
 import org.jcnc.snow.compiler.backend.core.InstructionGenerator;
-import org.jcnc.snow.compiler.backend.util.OpHelper;
+import org.jcnc.snow.compiler.backend.utils.OpHelper;
 import org.jcnc.snow.compiler.ir.instruction.LoadConstInstruction;
 import org.jcnc.snow.compiler.ir.value.IRConstant;
 import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
diff --git a/src/main/java/org/jcnc/snow/compiler/backend/generator/ReturnGenerator.java b/src/main/java/org/jcnc/snow/compiler/backend/generator/ReturnGenerator.java
index a58af50..6a48847 100644
--- a/src/main/java/org/jcnc/snow/compiler/backend/generator/ReturnGenerator.java
+++ b/src/main/java/org/jcnc/snow/compiler/backend/generator/ReturnGenerator.java
@@ -2,7 +2,7 @@ package org.jcnc.snow.compiler.backend.generator;
 
 import org.jcnc.snow.compiler.backend.builder.VMProgramBuilder;
 import org.jcnc.snow.compiler.backend.core.InstructionGenerator;
-import org.jcnc.snow.compiler.backend.util.OpHelper;
+import org.jcnc.snow.compiler.backend.utils.OpHelper;
 import org.jcnc.snow.compiler.ir.instruction.ReturnInstruction;
 import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 
diff --git a/src/main/java/org/jcnc/snow/compiler/backend/generator/UnaryOpGenerator.java b/src/main/java/org/jcnc/snow/compiler/backend/generator/UnaryOpGenerator.java
index 46d1f53..a3de573 100644
--- a/src/main/java/org/jcnc/snow/compiler/backend/generator/UnaryOpGenerator.java
+++ b/src/main/java/org/jcnc/snow/compiler/backend/generator/UnaryOpGenerator.java
@@ -1,7 +1,7 @@
 package org.jcnc.snow.compiler.backend.generator;
 
-import org.jcnc.snow.compiler.backend.util.IROpCodeMapper;
-import org.jcnc.snow.compiler.backend.util.OpHelper;
+import org.jcnc.snow.compiler.backend.utils.IROpCodeMapper;
+import org.jcnc.snow.compiler.backend.utils.OpHelper;
 import org.jcnc.snow.compiler.backend.builder.VMProgramBuilder;
 import org.jcnc.snow.compiler.backend.core.InstructionGenerator;
 import org.jcnc.snow.compiler.ir.instruction.UnaryOperationInstruction;
diff --git a/src/main/java/org/jcnc/snow/compiler/backend/util/IROpCodeMapper.java b/src/main/java/org/jcnc/snow/compiler/backend/utils/IROpCodeMapper.java
similarity index 83%
rename from src/main/java/org/jcnc/snow/compiler/backend/util/IROpCodeMapper.java
rename to src/main/java/org/jcnc/snow/compiler/backend/utils/IROpCodeMapper.java
index 757e8a8..31c0033 100644
--- a/src/main/java/org/jcnc/snow/compiler/backend/util/IROpCodeMapper.java
+++ b/src/main/java/org/jcnc/snow/compiler/backend/utils/IROpCodeMapper.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.compiler.backend.util;
+package org.jcnc.snow.compiler.backend.utils;
 
 import org.jcnc.snow.compiler.ir.core.IROpCode;
 
@@ -82,12 +82,21 @@ public final class IROpCodeMapper {
         opcodeMap.put(IROpCode.NEG_D64, "D_NEG");
 
         // 比较运算映射
-        opcodeMap.put(IROpCode.CMP_EQ, "IC_E");   // 相等
-        opcodeMap.put(IROpCode.CMP_NE, "IC_NE");   // 不等
-        opcodeMap.put(IROpCode.CMP_LT, "IC_L");    // 小于
-        opcodeMap.put(IROpCode.CMP_GT, "IC_G");    // 大于
-        opcodeMap.put(IROpCode.CMP_LE, "IC_LE");   // 小于等于
-        opcodeMap.put(IROpCode.CMP_GE, "IC_GE");   // 大于等于
+        // 整形32位比较运算映射
+        opcodeMap.put(IROpCode.CMP_IEQ, "IC_E");   // 相等
+        opcodeMap.put(IROpCode.CMP_INE, "IC_NE");   // 不等
+        opcodeMap.put(IROpCode.CMP_ILT, "IC_L");    // 小于
+        opcodeMap.put(IROpCode.CMP_IGT, "IC_G");    // 大于
+        opcodeMap.put(IROpCode.CMP_ILE, "IC_LE");   // 小于等于
+        opcodeMap.put(IROpCode.CMP_IGE, "IC_GE");   // 大于等于
+
+        // 整形64位比较运算映射
+        opcodeMap.put(IROpCode.CMP_LEQ, "LC_E");   // 相等
+        opcodeMap.put(IROpCode.CMP_LNE, "LC_NE");   // 不等
+        opcodeMap.put(IROpCode.CMP_LLT, "LC_L");    // 小于
+        opcodeMap.put(IROpCode.CMP_LGT, "LC_G");    // 大于
+        opcodeMap.put(IROpCode.CMP_LLE, "LC_LE");   // 小于等于
+        opcodeMap.put(IROpCode.CMP_LGE, "LC_GE");   // 大于等于
 
         // 加载与存储
         opcodeMap.put(IROpCode.LOAD, "I_LOAD");  // 加载
diff --git a/src/main/java/org/jcnc/snow/compiler/backend/util/OpHelper.java b/src/main/java/org/jcnc/snow/compiler/backend/utils/OpHelper.java
similarity index 80%
rename from src/main/java/org/jcnc/snow/compiler/backend/util/OpHelper.java
rename to src/main/java/org/jcnc/snow/compiler/backend/utils/OpHelper.java
index bc632cf..de873b8 100644
--- a/src/main/java/org/jcnc/snow/compiler/backend/util/OpHelper.java
+++ b/src/main/java/org/jcnc/snow/compiler/backend/utils/OpHelper.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.compiler.backend.util;
+package org.jcnc.snow.compiler.backend.utils;
 
 import org.jcnc.snow.vm.engine.VMOpCode;
 
@@ -22,6 +22,11 @@ public final class OpHelper {
      */
     private static final Map<String, String> OPCODE_MAP;
 
+    /**
+     * opcode 字符串 → 指令名 的静态映射表
+     */
+    private static final Map<Integer, String> OPCODE_NAME_MAP;
+
     static {
         Map<String, String> map = new HashMap<>();
         map.put("I_ADD", Integer.toString(VMOpCode.I_ADD));
@@ -89,12 +94,18 @@ public final class OpHelper {
         map.put("L_OR", Integer.toString(VMOpCode.L_OR));
         map.put("L_XOR", Integer.toString(VMOpCode.L_XOR));
         map.put("JUMP", Integer.toString(VMOpCode.JUMP));
-        map.put("IC_E", Integer.toString(VMOpCode.IC_E));
-        map.put("IC_NE", Integer.toString(VMOpCode.IC_NE));
-        map.put("IC_G", Integer.toString(VMOpCode.IC_G));
-        map.put("IC_GE", Integer.toString(VMOpCode.IC_GE));
-        map.put("IC_L", Integer.toString(VMOpCode.IC_L));
-        map.put("IC_LE", Integer.toString(VMOpCode.IC_LE));
+        map.put("IC_E", Integer.toString(VMOpCode.I_CE));
+        map.put("IC_NE", Integer.toString(VMOpCode.I_CNE));
+        map.put("IC_G", Integer.toString(VMOpCode.I_CG));
+        map.put("IC_GE", Integer.toString(VMOpCode.I_CGE));
+        map.put("IC_L", Integer.toString(VMOpCode.I_CL));
+        map.put("IC_LE", Integer.toString(VMOpCode.I_CLE));
+        map.put("LC_E", Integer.toString(VMOpCode.L_CE));
+        map.put("LC_NE", Integer.toString(VMOpCode.L_CNE));
+        map.put("LC_G", Integer.toString(VMOpCode.L_CG));
+        map.put("LC_GE", Integer.toString(VMOpCode.L_CGE));
+        map.put("LC_L", Integer.toString(VMOpCode.L_CL));
+        map.put("LC_LE", Integer.toString(VMOpCode.L_CLE));
         map.put("I_PUSH", Integer.toString(VMOpCode.I_PUSH));
         map.put("L_PUSH", Integer.toString(VMOpCode.L_PUSH));
         map.put("S_PUSH", Integer.toString(VMOpCode.S_PUSH));
@@ -121,6 +132,11 @@ public final class OpHelper {
         map.put("RET", Integer.toString(VMOpCode.RET));
         map.put("HALT", Integer.toString(VMOpCode.HALT));
         OPCODE_MAP = Collections.unmodifiableMap(map);
+
+        Map<Integer, String> revmap = new HashMap<>();  // reverse map
+        OPCODE_MAP.forEach((key, value) -> revmap.put(Integer.parseInt(value), key));
+
+        OPCODE_NAME_MAP = Collections.unmodifiableMap(revmap);
     }
 
     /**
@@ -164,5 +180,27 @@ public final class OpHelper {
         throw new IllegalStateException("Unknown const type: " + v.getClass());
     }
 
+    /**
+     * 根据 opcode 数值的字符串形式获取指令名
+     * @param code 字符串形式的 opcode 数值
+     * @return opcode 对应的指令名
+     */
+    public static String opcodeName(String code) {
+        return opcodeName(Integer.parseInt(code));
+    }
+
+    /**
+     * 根据 opcode 获取指令名
+     * @param code opcode
+     * @return opcode 对应的指令名
+     */
+    public static String opcodeName(int code) {
+        String name = OPCODE_NAME_MAP.get(code);
+        if (name == null) {
+            throw new IllegalStateException("Unknown opcode: " + name);
+        }
+        return name;
+    }
+
     // endregion
 }
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/compiler/cli/SnowCompiler.java b/src/main/java/org/jcnc/snow/compiler/cli/SnowCompiler.java
deleted file mode 100644
index fa0831a..0000000
--- a/src/main/java/org/jcnc/snow/compiler/cli/SnowCompiler.java
+++ /dev/null
@@ -1,149 +0,0 @@
-package org.jcnc.snow.compiler.cli;
-
-import org.jcnc.snow.compiler.backend.alloc.RegisterAllocator;
-import org.jcnc.snow.compiler.backend.builder.VMCodeGenerator;
-import org.jcnc.snow.compiler.backend.builder.VMProgramBuilder;
-import org.jcnc.snow.compiler.backend.core.InstructionGenerator;
-import org.jcnc.snow.compiler.backend.generator.*;
-import org.jcnc.snow.compiler.ir.builder.IRProgramBuilder;
-import org.jcnc.snow.compiler.ir.core.IRFunction;
-import org.jcnc.snow.compiler.ir.core.IRInstruction;
-import org.jcnc.snow.compiler.ir.core.IRProgram;
-import org.jcnc.snow.compiler.lexer.core.LexerEngine;
-import org.jcnc.snow.compiler.parser.ast.base.Node;
-import org.jcnc.snow.compiler.parser.context.ParserContext;
-import org.jcnc.snow.compiler.parser.core.ParserEngine;
-import org.jcnc.snow.compiler.parser.function.ASTPrinter;
-import org.jcnc.snow.compiler.semantic.core.SemanticAnalyzerRunner;
-import org.jcnc.snow.vm.engine.VMMode;
-import org.jcnc.snow.vm.engine.VirtualMachineEngine;
-
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.*;
-import java.util.*;
-
-/**
- * SnowCompiler CLI —— 多文件 / 单文件 / 目录 模式。
- */
-public class SnowCompiler {
-
-    public static void main(String[] args) throws IOException {
-        if (args.length == 0) {
-            System.err.println("""
-                    Usage:
-                      snow  <file1.snow> [file2.snow …]
-                      snow -d <srcDir>     (compile all *.snow recursively)
-                    """);
-            return;
-        }
-
-        /* ---------- 1. 收集所有待编译源码 ---------- */
-        List<Path> sources = collectSources(args);
-        if (sources.isEmpty()) {
-            System.err.println("No .snow source files found.");
-            return;
-        }
-
-        /* ---------- 2. 逐个词法+语法分析，合并 AST ---------- */
-        List<Node> allAst = new ArrayList<>();
-        for (Path p : sources) {
-            if (!Files.exists(p)) {
-                System.err.println("File not found: " + p);
-                return;
-            }
-            String code = Files.readString(p, StandardCharsets.UTF_8);
-
-            // 保持原有“## 源代码”打印，但标注文件名，兼容旧脚本
-            System.out.println("## 源代码 (" + p.getFileName() + ")");
-            System.out.println(code);
-
-            LexerEngine lexer = new LexerEngine(code, p.toString());
-            ParserContext ctx = new ParserContext(lexer.getAllTokens(), p.toString());
-            allAst.addAll(new ParserEngine(ctx).parse());
-        }
-
-        /* ---------- 3. 语义分析 ---------- */
-        SemanticAnalyzerRunner.runSemanticAnalysis(allAst, false);
-
-        /* ---------- 4. AST → IR ---------- */
-        IRProgram program = new IRProgramBuilder().buildProgram(allAst);
-        program = reorderForEntry(program);    // 保证入口 main 在首位
-
-        System.out.println("## 编译器输出");
-        System.out.println("### AST");
-        ASTPrinter.printJson(allAst);
-        System.out.println("### IR");
-        System.out.println(program);
-
-        /* ---------- 5. IR → VM 指令 ---------- */
-        VMProgramBuilder builder = new VMProgramBuilder();
-        List<InstructionGenerator<? extends IRInstruction>> generators = Arrays.asList(
-                new LoadConstGenerator(),
-                new BinaryOpGenerator(),
-                new UnaryOpGenerator(),
-                new CallGenerator(),
-                new ReturnGenerator(),
-                new LabelGenerator(),
-                new JumpGenerator(),
-                new CmpJumpGenerator()
-        );
-
-        for (IRFunction fn : program.functions()) {
-            Map<org.jcnc.snow.compiler.ir.value.IRVirtualRegister, Integer> slotMap =
-                    new RegisterAllocator().allocate(fn);
-            new VMCodeGenerator(slotMap, builder, generators).generate(fn);
-        }
-        List<String> finalCode = builder.build();
-
-        System.out.println("### VM code");
-        finalCode.forEach(System.out::println);
-
-        /* ---------- 6. 运行虚拟机 ---------- */
-        VirtualMachineEngine vm = new VirtualMachineEngine(VMMode.RUN);
-        vm.execute(finalCode);
-        vm.printLocalVariables();
-    }
-
-
-    /**
-     * 根据参数收集待编译文件：
-     *   - snow file1 file2 …      ← 多文件 / 单文件
-     *   - snow -d srcDir          ← 目录递归所有 *.snow
-     */
-    private static List<Path> collectSources(String[] args) throws IOException {
-        if (args.length == 2 && "-d".equals(args[0])) {
-            Path dir = Path.of(args[1]);
-            if (!Files.isDirectory(dir)) {
-                System.err.println("Not a directory: " + dir);
-                return List.of();
-            }
-            try (var stream = Files.walk(dir)) {
-                return stream.filter(p -> p.toString().endsWith(".snow"))
-                        .sorted()          // 稳定顺序，方便比对输出
-                        .toList();
-            }
-        }
-        // 普通文件参数
-        return Arrays.stream(args).map(Path::of).toList();
-    }
-
-    /**
-     * 把 main 函数放到 Program.functions()[0]，保证 PC=0 即入口；
-     * 如果用户未写 main，则保持原顺序（语义分析会报错）。
-     */
-    private static IRProgram reorderForEntry(IRProgram in) {
-        List<IRFunction> ordered = new ArrayList<>(in.functions());
-        int idx = -1;
-        for (int i = 0; i < ordered.size(); i++) {
-            if ("main".equals(ordered.get(i).name())) {
-                idx = i; break;
-            }
-        }
-        if (idx > 0) Collections.swap(ordered, 0, idx);
-
-        IRProgram out = new IRProgram();
-        ordered.forEach(out::add);
-        return out;
-    }
-}
diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/ExpressionBuilder.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/ExpressionBuilder.java
index 11288ba..f53d8cc 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/builder/ExpressionBuilder.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/ExpressionBuilder.java
@@ -4,6 +4,7 @@ import org.jcnc.snow.compiler.ir.core.IROpCode;
 import org.jcnc.snow.compiler.ir.instruction.CallInstruction;
 import org.jcnc.snow.compiler.ir.instruction.LoadConstInstruction;
 import org.jcnc.snow.compiler.ir.instruction.UnaryOperationInstruction;
+import org.jcnc.snow.compiler.ir.utils.ComparisonUtils;
 import org.jcnc.snow.compiler.ir.value.IRConstant;
 import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 import org.jcnc.snow.compiler.ir.utils.ExpressionUtils;
@@ -90,7 +91,7 @@ public record ExpressionBuilder(IRContext ctx) {
         //  !x  →  (x == 0)
         if (op.equals("!")) {
             IRVirtualRegister zero = InstructionFactory.loadConst(ctx, 0);
-            return InstructionFactory.binOp(ctx, IROpCode.CMP_EQ, val, zero);
+            return InstructionFactory.binOp(ctx, IROpCode.CMP_IEQ, val, zero);
         }
 
         throw new IllegalStateException("未知一元运算符: " + op);
@@ -109,7 +110,7 @@ public record ExpressionBuilder(IRContext ctx) {
         switch (node) {
             // 数字字面量，直接加载到目标寄存器
             case NumberLiteralNode n ->
-                    InstructionFactory.loadConstInto(ctx, dest, ExpressionUtils.parseIntSafely(n.value()));
+                    InstructionFactory.loadConstInto(ctx, dest, ExpressionUtils.buildNumberConstant(ctx, n.value()));
             // 标识符，查找并move到目标寄存器
             case IdentifierNode id -> {
                 IRVirtualRegister src = ctx.getScope().lookup(id.name());
@@ -137,13 +138,18 @@ public record ExpressionBuilder(IRContext ctx) {
      */
     private IRVirtualRegister buildBinary(BinaryExpressionNode bin) {
         String op = bin.operator();
-        IRVirtualRegister left = build(bin.left());
+        IRVirtualRegister left  = build(bin.left());
         IRVirtualRegister right = build(bin.right());
-        // 处理比较操作符
-        if (ExpressionUtils.isComparisonOperator(op)) {
-            return InstructionFactory.binOp(ctx, ExpressionUtils.cmpOp(op), left, right);
+
+        // 1. 比较运算
+        if (ComparisonUtils.isComparisonOperator(op)) {
+            return InstructionFactory.binOp(
+                    ctx,
+                    ComparisonUtils.cmpOp(op, bin.left(), bin.right()),
+                    left, right);
         }
-        // 处理算术运算符
+
+        // 2. 其他算术 / 逻辑运算
         IROpCode code = ExpressionUtils.resolveOpCode(op, bin.left(), bin.right());
         if (code == null) throw new IllegalStateException("不支持的运算符: " + op);
         return InstructionFactory.binOp(ctx, code, left, right);
@@ -161,8 +167,12 @@ public record ExpressionBuilder(IRContext ctx) {
         IRVirtualRegister a = build(bin.left());
         IRVirtualRegister b = build(bin.right());
         String op = bin.operator();
-        if (ExpressionUtils.isComparisonOperator(op)) {
-            InstructionFactory.binOpInto(ctx, ExpressionUtils.cmpOp(op), a, b, dest);
+
+        if (ComparisonUtils.isComparisonOperator(op)) {
+            InstructionFactory.binOpInto(
+                    ctx,
+                    ComparisonUtils.cmpOp(op, bin.left(), bin.right()),
+                    a, b, dest);
         } else {
             IROpCode code = ExpressionUtils.resolveOpCode(op, bin.left(), bin.right());
             if (code == null) throw new IllegalStateException("不支持的运算符: " + op);
@@ -207,7 +217,7 @@ public record ExpressionBuilder(IRContext ctx) {
      * @return 存放该常量的寄存器
      */
     private IRVirtualRegister buildNumberLiteral(String value) {
-        IRConstant constant = ExpressionUtils.buildNumberConstant(value);
+        IRConstant constant = ExpressionUtils.buildNumberConstant(ctx, value);
         IRVirtualRegister reg = ctx.newRegister();
         ctx.addInstruction(new LoadConstInstruction(reg, constant));
         return reg;
diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/FunctionBuilder.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/FunctionBuilder.java
index cc14557..48b10e7 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/builder/FunctionBuilder.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/FunctionBuilder.java
@@ -51,7 +51,7 @@ public class FunctionBuilder {
             // 2) 声明形参：为每个参数分配虚拟寄存器并声明到作用域
             for (ParameterNode p : functionNode.parameters()) {
                 IRVirtualRegister reg = irFunction.newRegister(); // 新寄存器
-                irContext.getScope().declare(p.name(), reg);      // 变量名→寄存器绑定
+                irContext.getScope().declare(p.name(), p.type(), reg);      // 变量名→寄存器绑定
                 irFunction.addParameter(reg);                     // 添加到函数参数列表
             }
 
diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRBuilderScope.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRBuilderScope.java
index 168eac2..e0fd4cf 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRBuilderScope.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRBuilderScope.java
@@ -24,6 +24,13 @@ final class IRBuilderScope {
      */
     private final Map<String, IRVirtualRegister> vars = new HashMap<>();
 
+    /**
+     * 存储变量名到对应类型的映射。
+     * <br>
+     * 变量名为键，变量类型为值，用于变量类型提升。
+     */
+    private final Map<String, String> varTypes = new HashMap<>();
+
     /**
      * 当前作用域所绑定的 IRFunction 对象，用于申请新的虚拟寄存器。
      */
@@ -44,10 +51,12 @@ final class IRBuilderScope {
      * 调用绑定的 IRFunction.newRegister() 生成寄存器后保存到映射表中。
      *
      * @param name 变量名称，作为映射键使用
+     * @param type 变量类型
      */
-    void declare(String name) {
+    void declare(String name, String type) {
         IRVirtualRegister reg = fn.newRegister();
         vars.put(name, reg);
+        varTypes.put(name, type);
     }
 
     /**
@@ -55,10 +64,12 @@ final class IRBuilderScope {
      * 该方法可用于将外部或前一作用域的寄存器导入到本作用域。
      *
      * @param name 变量名称，作为映射键使用
+     * @param type 变量类型
      * @param reg  要绑定到该名称的 IRVirtualRegister 实例
      */
-    void declare(String name, IRVirtualRegister reg) {
+    void declare(String name, String type, IRVirtualRegister reg) {
         vars.put(name, reg);
+        varTypes.put(name, type);
     }
 
     /**
@@ -82,4 +93,15 @@ final class IRBuilderScope {
     IRVirtualRegister lookup(String name) {
         return vars.get(name);
     }
+
+    /**
+     * 根据变量名称在当前作用域中查找对应的类型。
+     *
+     * @param name 需要查询的变量名称
+     * @return 如果该名称已声明，则返回对应的类型
+     *         如果未声明，则返回 null
+     */
+    String lookupType(String name) {
+        return varTypes.get(name);
+    }
 }
diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRContext.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRContext.java
index 4c5078d..26b8c0d 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRContext.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRContext.java
@@ -4,6 +4,7 @@ import org.jcnc.snow.compiler.ir.core.IRFunction;
 import org.jcnc.snow.compiler.ir.core.IRInstruction;
 import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 
+
 /**
  * IRContext 类负责封装当前正在构建的 IRFunction 实例
  * 以及与之配套的作用域管理（IRBuilderScope），
@@ -31,6 +32,11 @@ public class IRContext {
      */
     private final IRBuilderScope scope;
 
+    /**
+     * 当前声明变量的类型，不在声明变量时为空
+     */
+    private String varType;
+
     /**
      * 构造一个新的 IRContext，并将指定的 IRFunction 与作用域关联。
      *
@@ -41,6 +47,7 @@ public class IRContext {
         this.scope = new IRBuilderScope();
         // 关联作用域与 IRFunction，以便在声明变量时申请寄存器
         this.scope.attachFunction(function);
+        this.varType = null;
     }
 
     /**
@@ -85,4 +92,29 @@ public class IRContext {
     public String newLabel() {
         return "L" + (labelCounter++);
     }
+
+    /**
+     * 获取当前 declare 编译阶段变量类型
+     *
+     * @return 当前 declare 的变量类型
+     */
+    public String getVarType() {
+        return varType;
+    }
+
+    /**
+     * 设置当前 declare 编译阶段变量类型
+     *
+     */
+    public void setVarType(String type) {
+        this.varType = type;
+    }
+
+    /**
+     * 清除当前 declare 编译阶段变量类型
+     *
+     */
+    public void clearVarType() {
+        this.varType = null;
+    }
 }
diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java
index a1168ec..5513fdc 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/IRProgramBuilder.java
@@ -76,6 +76,14 @@ public final class IRProgramBuilder {
      * @return 生成的 FunctionNode，用于后续 IRFunction 构建
      */
     private FunctionNode wrapTopLevel(StatementNode stmt) {
-        return new FunctionNode("_start", null, String.valueOf(List.of()), List.of(stmt));
+        return new FunctionNode(
+                "_start",
+                null,
+                String.valueOf(List.of()),
+                List.of(stmt),
+                -1,
+                -1,
+                ""
+        );
     }
 }
diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/InstructionFactory.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/InstructionFactory.java
index 9b7a467..6c5881a 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/builder/InstructionFactory.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/InstructionFactory.java
@@ -58,8 +58,8 @@ public class InstructionFactory {
      * @param dest  目标寄存器
      * @param value 要加载的整数常量
      */
-    public static void loadConstInto(IRContext ctx, IRVirtualRegister dest, int value) {
-        ctx.addInstruction(new LoadConstInstruction(dest, new IRConstant(value)));
+    public static void loadConstInto(IRContext ctx, IRVirtualRegister dest, IRConstant value) {
+        ctx.addInstruction(new LoadConstInstruction(dest, value));
     }
 
     /**
diff --git a/src/main/java/org/jcnc/snow/compiler/ir/builder/StatementBuilder.java b/src/main/java/org/jcnc/snow/compiler/ir/builder/StatementBuilder.java
index 8a95ca5..f731c57 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/builder/StatementBuilder.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/builder/StatementBuilder.java
@@ -1,7 +1,7 @@
 package org.jcnc.snow.compiler.ir.builder;
 
 import org.jcnc.snow.compiler.ir.core.IROpCode;
-import org.jcnc.snow.compiler.ir.utils.ExpressionUtils;
+import org.jcnc.snow.compiler.ir.utils.ComparisonUtils;
 import org.jcnc.snow.compiler.ir.utils.IROpCodeUtils;
 import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
 import org.jcnc.snow.compiler.parser.ast.*;
@@ -18,23 +18,41 @@ import java.util.Locale;
  */
 public class StatementBuilder {
 
-    /** 当前 IR 上下文，包含作用域、指令序列等信息。 */
+    /**
+     * 当前 IR 上下文，包含作用域、指令序列等信息。
+     */
     private final IRContext ctx;
-    /** 表达式 IR 构建器，用于将表达式节点转为 IR 指令。 */
+    /**
+     * 表达式 IR 构建器，用于将表达式节点转为 IR 指令。
+     */
     private final ExpressionBuilder expr;
 
     /**
      * 构造方法。
+     *
      * @param ctx IR 编译上下文环境
      */
     public StatementBuilder(IRContext ctx) {
-        this.ctx  = ctx;
+        this.ctx = ctx;
         this.expr = new ExpressionBuilder(ctx);
     }
 
+    private static char typeSuffixFromType(String type) {
+        if (type == null) return '\0';
+        return switch (type.toLowerCase(Locale.ROOT)) {
+            case "byte" -> 'b';
+            case "short" -> 's';
+            case "long" -> 'l';
+            case "float" -> 'f';
+            case "double" -> 'd';
+            default -> '\0';   // 其余默认按 32-bit 整型处理
+        };
+    }
+
     /**
      * 将一个 AST 语句节点转为 IR 指令序列。
      * 根据节点类型分发到对应的处理方法。
+     *
      * @param stmt 待转换的语句节点
      */
     public void build(StatementNode stmt) {
@@ -48,26 +66,44 @@ public class StatementBuilder {
             buildIf(ifNode);
             return;
         }
-        if (stmt instanceof ExpressionStatementNode(ExpressionNode exp)) {
+        if (stmt instanceof ExpressionStatementNode(ExpressionNode exp, _, _, _)) {
             // 纯表达式语句，如 foo();
             expr.build(exp);
             return;
         }
-        if (stmt instanceof AssignmentNode(String var, ExpressionNode rhs)) {
+        if (stmt instanceof AssignmentNode(String var, ExpressionNode rhs, _, _, _)) {
             // 赋值语句，如 a = b + 1;
-            IRVirtualRegister target = getOrDeclareRegister(var);
+
+            final String type = ctx.getScope().lookupType(var);
+
+            // 1. 设置声明变量的类型
+            ctx.setVarType(type);
+
+            IRVirtualRegister target = getOrDeclareRegister(var, type);
             expr.buildInto(rhs, target);
+
+            // 2. 清除变量声明
+            ctx.clearVarType();
+
             return;
         }
         if (stmt instanceof DeclarationNode decl) {
             // 变量声明，如 int a = 1;
             if (decl.getInitializer().isPresent()) {
                 // 声明同时有初值
+
+                // 1. 设置声明变量的类型
+                ctx.setVarType(decl.getType());
+
                 IRVirtualRegister r = expr.build(decl.getInitializer().get());
-                ctx.getScope().declare(decl.getName(), r);
+
+                // 2. 清除变量声明
+                ctx.clearVarType();
+
+                ctx.getScope().declare(decl.getName(), decl.getType(), r);
             } else {
                 // 仅声明，无初值
-                ctx.getScope().declare(decl.getName());
+                ctx.getScope().declare(decl.getName(), decl.getType());
             }
             return;
         }
@@ -89,20 +125,22 @@ public class StatementBuilder {
 
     /**
      * 获取变量名对应的寄存器，不存在则声明一个新的。
+     *
      * @param name 变量名
      * @return 变量对应的虚拟寄存器
      */
-    private IRVirtualRegister getOrDeclareRegister(String name) {
+    private IRVirtualRegister getOrDeclareRegister(String name, String type) {
         IRVirtualRegister reg = ctx.getScope().lookup(name);
         if (reg == null) {
             reg = ctx.newRegister();
-            ctx.getScope().declare(name, reg);
+            ctx.getScope().declare(name, type, reg);
         }
         return reg;
     }
 
     /**
      * 批量构建一组语句节点，顺序处理每个语句。
+     *
      * @param stmts 语句节点集合
      */
     private void buildStatements(Iterable<StatementNode> stmts) {
@@ -112,12 +150,13 @@ public class StatementBuilder {
     /**
      * 构建循环语句（for/while）。
      * 处理流程：初始语句 → 条件判断 → 循环体 → 更新语句 → 跳回条件。
+     *
      * @param loop 循环节点
      */
     private void buildLoop(LoopNode loop) {
         if (loop.initializer() != null) build(loop.initializer());
         String lblStart = ctx.newLabel();
-        String lblEnd   = ctx.newLabel();
+        String lblEnd = ctx.newLabel();
         // 循环开始标签
         InstructionFactory.label(ctx, lblStart);
 
@@ -137,11 +176,12 @@ public class StatementBuilder {
     /**
      * 构建分支语句（if/else）。
      * 处理流程：条件判断 → then 分支 → else 分支（可选）。
+     *
      * @param ifNode if 语句节点
      */
     private void buildIf(IfNode ifNode) {
         String lblElse = ctx.newLabel();
-        String lblEnd  = ctx.newLabel();
+        String lblEnd = ctx.newLabel();
         // 条件不成立则跳转到 else
         emitConditionalJump(ifNode.condition(), lblElse);
 
@@ -160,35 +200,33 @@ public class StatementBuilder {
     /**
      * 条件跳转指令的生成。
      * 如果是二元比较表达式，直接使用对应比较操作码；否则等价于与 0 比较。
-     * @param cond      条件表达式
+     *
+     * @param cond       条件表达式
      * @param falseLabel 条件不成立时跳转到的标签
      */
     private void emitConditionalJump(ExpressionNode cond, String falseLabel) {
-        if (cond instanceof BinaryExpressionNode(ExpressionNode left, String operator, ExpressionNode right)
-                && ExpressionUtils.isComparisonOperator(operator)) {
-            // 如果是比较操作（如 ==, >, <），直接生成对应的条件跳转
+        if (cond instanceof BinaryExpressionNode(
+                ExpressionNode left,
+                String operator,
+                ExpressionNode right,
+                _,
+                _,
+                _
+        )
+                && ComparisonUtils.isComparisonOperator(operator)) {
+
             IRVirtualRegister a = expr.build(left);
             IRVirtualRegister b = expr.build(right);
-            // 获取反向比较操作码
-            IROpCode falseOp   = IROpCodeUtils.invert(ExpressionUtils.cmpOp(operator));
+
+            // 使用适配后位宽正确的比较指令
+            IROpCode cmp = ComparisonUtils.cmpOp(operator, left, right);
+            IROpCode falseOp = IROpCodeUtils.invert(cmp);
+
             InstructionFactory.cmpJump(ctx, falseOp, a, b, falseLabel);
         } else {
-            // 否则将 cond 与 0 比较，相等则跳转
             IRVirtualRegister condReg = expr.build(cond);
-            IRVirtualRegister zero    = InstructionFactory.loadConst(ctx, 0);
-            InstructionFactory.cmpJump(ctx, IROpCode.CMP_EQ, condReg, zero, falseLabel);
+            IRVirtualRegister zero = InstructionFactory.loadConst(ctx, 0);
+            InstructionFactory.cmpJump(ctx, IROpCode.CMP_IEQ, condReg, zero, falseLabel);
         }
     }
-
-    private static char typeSuffixFromType(String type) {
-        if (type == null) return '\0';
-        return switch (type.toLowerCase(Locale.ROOT)) {
-            case "byte"   -> 'b';
-            case "short"  -> 's';
-            case "long"   -> 'l';
-            case "float"  -> 'f';
-            case "double" -> 'd';
-            default       -> '\0';   // 其余默认按 32-bit 整型处理
-        };
-    }
 }
diff --git a/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCode.java b/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCode.java
index 24e86e3..c45a454 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCode.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCode.java
@@ -66,13 +66,21 @@ public enum IROpCode {
     DIV_D64,   // 64位浮点除法
     NEG_D64,   // 64位浮点取负
 
-    /* ───── 逻辑与比较运算指令 ───── */
-    CMP_EQ,    // 相等比较：a == b
-    CMP_NE,    // 不等比较：a != b
-    CMP_LT,    // 小于比较：a < b
-    CMP_GT,    // 大于比较：a > b
-    CMP_LE,    // 小于等于：a <= b
-    CMP_GE,    // 大于等于：a >= b
+    /* ───── 逻辑与比较运算指令（32位整数：int） ───── */
+    CMP_IEQ,    // 32位相等比较：a == b
+    CMP_INE,    // 32位不等比较：a != b
+    CMP_ILT,    // 32位小于比较：a < b
+    CMP_IGT,    // 32位大于比较：a > b
+    CMP_ILE,    // 32位小于等于：a <= b
+    CMP_IGE,    // 32位大于等于：a >= b
+
+    /* ───── 逻辑与比较运算指令（64位整数：long） ───── */
+    CMP_LEQ,    // 64位相等比较：a == b
+    CMP_LNE,    // 64位不等比较：a != b
+    CMP_LLT,    // 64位小于比较：a < b
+    CMP_LGT,    // 64位大于比较：a > b
+    CMP_LLE,    // 64位小于等于：a <= b
+    CMP_LGE,    // 64位大于等于：a >= b
 
     /* ───── 数据访问与常量操作 ───── */
     LOAD,      // 从内存加载数据至寄存器
diff --git a/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCodeMappings.java b/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCodeMappings.java
index 69e985e..32593d9 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCodeMappings.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCodeMappings.java
@@ -9,12 +9,12 @@ public final class IROpCodeMappings {
     private IROpCodeMappings() {} // 禁止实例化
 
     // 8位整型运算符映射
-    public static final Map<String, IROpCode> OP_I8 = Map.of(
+    public static final Map<String, IROpCode> OP_B8 = Map.of(
             "+", IROpCode.ADD_B8, "-", IROpCode.SUB_B8,
             "*", IROpCode.MUL_B8, "/", IROpCode.DIV_B8
     );
     // 16位整型
-    public static final Map<String, IROpCode> OP_I16 = Map.of(
+    public static final Map<String, IROpCode> OP_S16 = Map.of(
             "+", IROpCode.ADD_S16, "-", IROpCode.SUB_S16,
             "*", IROpCode.MUL_S16, "/", IROpCode.DIV_S16
     );
@@ -38,13 +38,27 @@ public final class IROpCodeMappings {
             "+", IROpCode.ADD_D64, "-", IROpCode.SUB_D64,
             "*", IROpCode.MUL_D64, "/", IROpCode.DIV_D64
     );
-    // 比较操作符映射
-    public static final Map<String, IROpCode> CMP = Map.of(
-            "==", IROpCode.CMP_EQ,
-            "!=", IROpCode.CMP_NE,
-            "<",  IROpCode.CMP_LT,
-            ">",  IROpCode.CMP_GT,
-            "<=", IROpCode.CMP_LE,
-            ">=", IROpCode.CMP_GE
+
+    /* ────── 比较运算符映射 ────── */
+    /** 32-bit（int）比较 */
+    public static final Map<String, IROpCode> CMP_I32 = Map.of(
+            "==", IROpCode.CMP_IEQ,
+            "!=", IROpCode.CMP_INE,
+            "<",  IROpCode.CMP_ILT,
+            ">",  IROpCode.CMP_IGT,
+            "<=", IROpCode.CMP_ILE,
+            ">=", IROpCode.CMP_IGE
     );
+
+    /** 64-bit（long）比较 */
+    public static final Map<String, IROpCode> CMP_L64 = Map.of(
+            "==", IROpCode.CMP_LEQ,
+            "!=", IROpCode.CMP_LNE,
+            "<",  IROpCode.CMP_LLT,
+            ">",  IROpCode.CMP_LGT,
+            "<=", IROpCode.CMP_LLE,
+            ">=", IROpCode.CMP_LGE
+    );
+
+    
 }
diff --git a/src/main/java/org/jcnc/snow/compiler/ir/utils/ComparisonUtils.java b/src/main/java/org/jcnc/snow/compiler/ir/utils/ComparisonUtils.java
new file mode 100644
index 0000000..59042e9
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/compiler/ir/utils/ComparisonUtils.java
@@ -0,0 +1,49 @@
+package org.jcnc.snow.compiler.ir.utils;
+
+import org.jcnc.snow.compiler.ir.core.IROpCode;
+import org.jcnc.snow.compiler.ir.core.IROpCodeMappings;
+import org.jcnc.snow.compiler.parser.ast.NumberLiteralNode;
+import org.jcnc.snow.compiler.parser.ast.base.ExpressionNode;
+
+import java.util.Map;
+
+/**
+ * 比较运算辅助工具：
+ * 根据左右操作数类型（目前通过字面量后缀 <code>L/l</code> 判定）选择
+ * 正确的 IR 比较指令，保证 int/long 均能正常运行。
+ */
+public final class ComparisonUtils {
+    private ComparisonUtils() {
+    }
+
+    /**
+     * 判断给定操作符是否为比较运算符
+     */
+    public static boolean isComparisonOperator(String op) {
+        // 两张表 key 完全一致，只需检查一张
+        return IROpCodeMappings.CMP_I32.containsKey(op);
+    }
+
+    /**
+     * 返回符合操作数位宽的比较 IROpCode。
+     *
+     * @param op    比较符号（==, !=, <, >, <=, >=）
+     * @param left  左操作数 AST
+     * @param right 右操作数 AST
+     */
+    public static IROpCode cmpOp(String op, ExpressionNode left, ExpressionNode right) {
+        boolean useLong = isLongLiteral(left) || isLongLiteral(right);
+        Map<String, IROpCode> table = useLong ? IROpCodeMappings.CMP_L64
+                : IROpCodeMappings.CMP_I32;
+        return table.get(op);
+    }
+
+    /* ------------ 内部工具 ------------ */
+
+    private static boolean isLongLiteral(ExpressionNode node) {
+        if (node instanceof NumberLiteralNode(String value)) {
+            return value.endsWith("L") || value.endsWith("l");
+        }
+        return false;                   // 变量暂不处理（后续可扩展符号表查询）
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/compiler/ir/utils/ExpressionUtils.java b/src/main/java/org/jcnc/snow/compiler/ir/utils/ExpressionUtils.java
index 91155df..7c93c9a 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/utils/ExpressionUtils.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/utils/ExpressionUtils.java
@@ -1,5 +1,6 @@
 package org.jcnc.snow.compiler.ir.utils;
 
+import org.jcnc.snow.compiler.ir.builder.IRContext;
 import org.jcnc.snow.compiler.ir.core.IROpCode;
 import org.jcnc.snow.compiler.ir.core.IROpCodeMappings;
 import org.jcnc.snow.compiler.ir.value.IRConstant;
@@ -11,84 +12,83 @@ import java.util.Map;
 
 /**
  * 表达式分析与运算符辅助工具类。
- * <p>
- * 主要功能包括：
+ *
+ * <p>主要功能：</p>
  * <ul>
  *   <li>字面量常量的解析与类型推断</li>
- *   <li>自动匹配操作码</li>
- *   <li>表达式类型合并与判定</li>
+ *   <li>自动匹配算术/比较操作码</li>
+ *   <li>表达式类型合并与提升</li>
  * </ul>
  */
-public class ExpressionUtils {
+public final class ExpressionUtils {
 
-    /** 用于存储默认的类型后缀（如函数返回类型），线程隔离。 */
+    private ExpressionUtils() {}
+
+    /* ────────────────── 线程级默认类型后缀 ────────────────── */
+
+    /** 默认类型后缀（如当前函数返回类型），线程隔离。 */
     private static final ThreadLocal<Character> DEFAULT_SUFFIX =
             ThreadLocal.withInitial(() -> '\0');
 
-    /**
-     * 在进入函数 IR 构建前设置默认的类型后缀（比如函数返回类型）。
-     * @param suffix 默认后缀字符，如 'i', 'l', 'f', 'd' 等
-     */
-    public static void setDefaultSuffix(char suffix) {
-        DEFAULT_SUFFIX.set(suffix);
-    }
+    public static void setDefaultSuffix(char suffix) { DEFAULT_SUFFIX.set(suffix); }
 
-    /**
-     * 在函数 IR 构建结束后清除默认后缀，避免影响后续分析。
-     */
-    public static void clearDefaultSuffix() {
-        DEFAULT_SUFFIX.set('\0');
-    }
+    public static void clearDefaultSuffix()           { DEFAULT_SUFFIX.set('\0'); }
+
+    /* ───────────────────── 字面量 & 常量 ───────────────────── */
 
     /**
      * 解析整数字面量字符串，自动去除类型后缀（b/s/l/f/d/B/S/L/F/D），并转换为 int。
-     *
-     * @param literal 字面量字符串，如 "123", "123l", "42B"
-     * @return 解析得到的 int 整数
      */
     public static int parseIntSafely(String literal) {
-        // 去掉类型后缀，只保留数字部分
         String digits = literal.replaceAll("[bslfdBSDLF]$", "");
         return Integer.parseInt(digits);
     }
 
     /**
-     * 根据数字字面量字符串自动判断类型，生成对应类型的 IRConstant。
-     * 支持 b/s/l/f/d 类型后缀与浮点格式，自动分配合适类型。
-     *
-     * @param value 字面量字符串（如 "1", "2l", "3.14f", "5D"）
-     * @return 生成的 IRConstant 对象，包含正确类型
+     * 根据数字字面量字符串自动判断类型，生成对应类型的 {@link IRConstant}。
+     * 支持 b/s/l/f/d 后缀与浮点格式。
      */
-    public static IRConstant buildNumberConstant(String value) {
-        char suffix = value.isEmpty() ? '\0' : Character.toLowerCase(value.charAt(value.length() - 1));
+    public static IRConstant buildNumberConstant(IRContext ctx, String value) {
+        char suffix = value.isEmpty() ? '\0'
+                : Character.toLowerCase(value.charAt(value.length() - 1));
+
         String digits = switch (suffix) {
             case 'b','s','l','f','d' -> value.substring(0, value.length() - 1);
-            default -> value;
+            default -> {
+                /* 如果字面量本身没有后缀，则回退到变量目标类型（如声明语句左值） */
+                if (ctx.getVarType() != null) {
+                    String t = ctx.getVarType();
+                    suffix = switch (t) {
+                        case "byte"   -> 'b';
+                        case "short"  -> 's';
+                        case "int"    -> 'i';
+                        case "long"   -> 'l';
+                        case "float"  -> 'f';
+                        case "double" -> 'd';
+                        default       -> '\0';
+                    };
+                }
+                yield value;
+            }
         };
-        // 根据类型后缀或数值格式创建常量
+
+        /* 创建常量 */
         return switch (suffix) {
             case 'b' -> new IRConstant(Byte.parseByte(digits));
             case 's' -> new IRConstant(Short.parseShort(digits));
             case 'l' -> new IRConstant(Long.parseLong(digits));
             case 'f' -> new IRConstant(Float.parseFloat(digits));
             case 'd' -> new IRConstant(Double.parseDouble(digits));
-            default -> looksLikeFloat(digits)
+            default  -> looksLikeFloat(digits)
                     ? new IRConstant(Double.parseDouble(digits))
                     : new IRConstant(Integer.parseInt(digits));
         };
     }
 
+    /* ────────────────────── 一元运算 ────────────────────── */
+
     /**
-     * 根据表达式节点推断一元取负（-）运算应使用的操作码。
-     *
-     * <p>优先级与 {@link #resolveOpCode} 使用的类型提升规则保持一致：</p>
-     * <ul>
-     *   <li>字面量或标识符带显式后缀时，直接以后缀决定位宽；</li>
-     *   <li>未显式指定时，默认使用 32 位整型 {@link IROpCode#NEG_I32}。</li>
-     * </ul>
-     *
-     * @param operand 一元取负运算的操作数
-     * @return 匹配的 {@link IROpCode}
+     * 推断一元取负（-）运算应使用的 {@link IROpCode}。
      */
     public static IROpCode negOp(ExpressionNode operand) {
         char t = typeChar(operand);
@@ -98,113 +98,82 @@ public class ExpressionUtils {
             case 'l' -> IROpCode.NEG_L64;
             case 'f' -> IROpCode.NEG_F32;
             case 'd' -> IROpCode.NEG_D64;
-            default  -> IROpCode.NEG_I32;
+            default  -> IROpCode.NEG_I32;      // '\0' 或 'i'
         };
     }
 
-    /* =================== 类型推断与操作符匹配 =================== */
+    /* ────────────────── 比较运算（已适配 long） ────────────────── */
 
-    /**
-     * 递归推断单个表达式节点的类型后缀（b/s/l/f/d）。
-     * 对于二元表达式，将左右两侧的类型自动提升合并，遵循优先级顺序：d > f > l > s > b > '\0'。
-     *
-     * @param node 表达式节点
-     * @return 类型后缀字符，b/s/l/f/d 或 '\0'
-     */
-    private static char typeChar(ExpressionNode node) {
-        // 字面量节点，直接判断最后一位
-        if (node instanceof NumberLiteralNode(String value)) {
-            char last = Character.toLowerCase(value.charAt(value.length() - 1));
-            return switch (last) {
-                case 'b', 's', 'l', 'f', 'd' -> last;
-                default -> looksLikeFloat(value) ? 'd' : '\0';
-            };
-        }
-        // 二元表达式，递归判断左右子节点
-        if (node instanceof BinaryExpressionNode bin) {
-            char l = typeChar(bin.left());
-            char r = typeChar(bin.right());
-            return maxTypeChar(l, r);
-        }
-        // 其他情况（如变量节点），暂不处理，默认返回 '\0'
-        return '\0';
+    /** 判断给定字符串是否是比较运算符（==, !=, <, >, <=, >=）。 */
+    public static boolean isComparisonOperator(String op) {
+        return ComparisonUtils.isComparisonOperator(op);
     }
 
     /**
-     * 推断两个表达式节点合并后的类型后缀。
-     * 返回优先级更高的类型后缀字符。
-     *
-     * @param left  左表达式节点
-     * @param right 右表达式节点
-     * @return 合并后类型的后缀字符
+     * 兼容旧调用：仅凭操作符返回 <em>int32</em> 比较指令。
      */
+    public static IROpCode cmpOp(String op) {
+        return IROpCodeMappings.CMP_I32.get(op);     // 旧逻辑：一律 i32
+    }
+
+    /**
+     * 推荐调用：根据左右表达式类型自动选择 int / long 比较指令。
+     */
+    public static IROpCode cmpOp(String op, ExpressionNode left, ExpressionNode right) {
+        return ComparisonUtils.cmpOp(op, left, right);
+    }
+
+    /* ──────────────── 类型推断 & 算术操作码匹配 ──────────────── */
+
+    /** 递归推断单个表达式节点的类型后缀（b/s/i/l/f/d）。 */
+    private static char typeChar(ExpressionNode node) {
+        if (node instanceof NumberLiteralNode(String value)) {
+            char last = Character.toLowerCase(value.charAt(value.length() - 1));
+            return switch (last) {
+                case 'b','s','i','l','f','d' -> last;
+                default -> looksLikeFloat(value) ? 'd' : '\0';
+            };
+        }
+        if (node instanceof BinaryExpressionNode bin) {
+            return maxTypeChar(typeChar(bin.left()), typeChar(bin.right()));
+        }
+        return '\0';      // 变量等暂不处理
+    }
+
+    /** 合并两侧表达式的类型后缀。 */
     public static char resolveSuffix(ExpressionNode left, ExpressionNode right) {
         return maxTypeChar(typeChar(left), typeChar(right));
     }
 
-    /**
-     * 在两个类型后缀中选取精度更高的一个。
-     * 优先级依次为：d > f > l > s > b > '\0'
-     *
-     * @param l 左类型后缀
-     * @param r 右类型后缀
-     * @return 更高优先级的类型后缀字符
-     */
+    /** 类型优先级：d > f > l > i > s > b > '\0' */
     private static char maxTypeChar(char l, char r) {
         if (l == 'd' || r == 'd') return 'd';
         if (l == 'f' || r == 'f') return 'f';
         if (l == 'l' || r == 'l') return 'l';
+        if (l == 'i' || r == 'i') return 'i';
         if (l == 's' || r == 's') return 's';
         if (l == 'b' || r == 'b') return 'b';
         return '\0';
     }
 
     /**
-     * 判断给定字符串是否为比较运算符（如 >, <, == 等）。
-     *
-     * @param op 操作符字符串
-     * @return 如果是比较操作符返回 true，否则返回 false
-     */
-    public static boolean isComparisonOperator(String op) {
-        return IROpCodeMappings.CMP.containsKey(op);
-    }
-
-    /**
-     * 获取比较操作符对应的中间表示操作码（IROpCode）。
-     *
-     * @param op 比较操作符字符串
-     * @return 对应的 IROpCode，如果不存在则返回 null
-     */
-    public static IROpCode cmpOp(String op) {
-        return IROpCodeMappings.CMP.get(op);
-    }
-
-    /**
-     * 根据操作符和两侧表达式自动选择正确的 IROpCode。
-     * 首先根据参与表达式类型推断后缀，若无法推断则回退到函数默认类型，
-     * 还无法推断则默认使用 i32（32位整型）。
-     *
-     * @param op 操作符字符串，如 "+"
-     * @param left 左侧表达式节点
-     * @param right 右侧表达式节点
-     * @return 匹配的 IROpCode，如果不存在则返回 null
+     * 根据操作符和两侧表达式选择正确的算术 {@link IROpCode}。
      */
     public static IROpCode resolveOpCode(String op,
                                          ExpressionNode left,
                                          ExpressionNode right) {
 
-        /* 1) 尝试从参与者常量字面量推断 */
+        /* 1. 尝试根据字面量推断 */
         char suffix = resolveSuffix(left, right);
 
-        /* 2) 若无法推断，退回到函数返回类型（DEFAULT_SUFFIX） */
-        if (suffix == '\0') {
-            suffix = DEFAULT_SUFFIX.get();
-        }
+        /* 2. 若失败则使用函数级默认类型 */
+        if (suffix == '\0') suffix = DEFAULT_SUFFIX.get();
 
-        /* 3) 再次失败则默认为 i32 */
+        /* 3. 仍失败则默认为 int32 */
         Map<String, IROpCode> table = switch (suffix) {
-            case 'b' -> IROpCodeMappings.OP_I8;
-            case 's' -> IROpCodeMappings.OP_I16;
+            case 'b' -> IROpCodeMappings.OP_B8;
+            case 's' -> IROpCodeMappings.OP_S16;
+            case 'i' -> IROpCodeMappings.OP_I32;
             case 'l' -> IROpCodeMappings.OP_L64;
             case 'f' -> IROpCodeMappings.OP_F32;
             case 'd' -> IROpCodeMappings.OP_D64;
@@ -214,13 +183,12 @@ public class ExpressionUtils {
         return table.get(op);
     }
 
-    /**
-     * 判断字符串是否为浮点数形式（即包含小数点或科学计数法 e/E）。
-     *
-     * @param digits 数字字符串
-     * @return 如果看起来像浮点数则返回 true，否则返回 false
-     */
+    /* ────────────────────────── 工具 ───────────────────────── */
+
+    /** 是否像浮点字面量（包含 '.' 或 e/E）。 */
     private static boolean looksLikeFloat(String digits) {
-        return digits.indexOf('.') >= 0 || digits.indexOf('e') >= 0 || digits.indexOf('E') >= 0;
+        return digits.indexOf('.') >= 0
+                || digits.indexOf('e') >= 0
+                || digits.indexOf('E') >= 0;
     }
 }
diff --git a/src/main/java/org/jcnc/snow/compiler/ir/utils/IROpCodeUtils.java b/src/main/java/org/jcnc/snow/compiler/ir/utils/IROpCodeUtils.java
index dee9733..6e782a7 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/utils/IROpCodeUtils.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/utils/IROpCodeUtils.java
@@ -8,13 +8,21 @@ import java.util.Map;
  * IR 操作码辅助工具。
  */
 public class IROpCodeUtils {
-    private static final Map<IROpCode, IROpCode> INVERT = Map.of(
-        IROpCode.CMP_EQ, IROpCode.CMP_NE,
-        IROpCode.CMP_NE, IROpCode.CMP_EQ,
-        IROpCode.CMP_LT, IROpCode.CMP_GE,
-        IROpCode.CMP_GE, IROpCode.CMP_LT,
-        IROpCode.CMP_GT, IROpCode.CMP_LE,
-        IROpCode.CMP_LE, IROpCode.CMP_GT
+    private static final Map<IROpCode, IROpCode> INVERT = Map.ofEntries(
+            // 32-bit
+            Map.entry(IROpCode.CMP_IEQ, IROpCode.CMP_INE),
+            Map.entry(IROpCode.CMP_INE, IROpCode.CMP_IEQ),
+            Map.entry(IROpCode.CMP_ILT, IROpCode.CMP_IGE),
+            Map.entry(IROpCode.CMP_IGE, IROpCode.CMP_ILT),
+            Map.entry(IROpCode.CMP_IGT, IROpCode.CMP_ILE),
+            Map.entry(IROpCode.CMP_ILE, IROpCode.CMP_IGT),
+            // 64-bit
+            Map.entry(IROpCode.CMP_LEQ, IROpCode.CMP_LNE),
+            Map.entry(IROpCode.CMP_LNE, IROpCode.CMP_LEQ),
+            Map.entry(IROpCode.CMP_LLT, IROpCode.CMP_LGE),
+            Map.entry(IROpCode.CMP_LGE, IROpCode.CMP_LLT),
+            Map.entry(IROpCode.CMP_LGT, IROpCode.CMP_LLE),
+            Map.entry(IROpCode.CMP_LLE, IROpCode.CMP_LGT)
     );
 
     /**
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/AssignmentNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/AssignmentNode.java
index 69781b9..eace610 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/AssignmentNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/AssignmentNode.java
@@ -16,8 +16,17 @@ import org.jcnc.snow.compiler.parser.ast.base.StatementNode;
  *
  * @param variable 左值变量名（即赋值目标）
  * @param value    表达式右值（即赋值来源）
+ * @param line     当前节点所在的行号
+ * @param column   当前节点所在的列号
+ * @param file     当前节点所在的文件
  */
-public record AssignmentNode(String variable, ExpressionNode value) implements StatementNode {
+public record AssignmentNode(
+        String variable,
+        ExpressionNode value,
+        int line,
+        int column,
+        String file
+) implements StatementNode {
 
     /**
      * 返回赋值语句的字符串形式，便于调试与日志输出。
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/BinaryExpressionNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/BinaryExpressionNode.java
index 6e49e63..40412de 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/BinaryExpressionNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/BinaryExpressionNode.java
@@ -12,9 +12,18 @@ import org.jcnc.snow.compiler.parser.ast.base.ExpressionNode;
  * @param left     左操作数（子表达式）
  * @param operator 运算符字符串（如 "+", "-", "*", "/" 等）
  * @param right    右操作数（子表达式）
+ * @param line     当前节点所在的行号
+ * @param column   当前节点所在的列号
+ * @param file     当前节点所在的文件
  */
-public record BinaryExpressionNode(ExpressionNode left, String operator,
-                                   ExpressionNode right) implements ExpressionNode {
+public record BinaryExpressionNode(
+        ExpressionNode left,
+        String operator,
+        ExpressionNode right,
+        int line,
+        int column,
+        String file
+) implements ExpressionNode {
 
     /**
      * 返回该二元运算表达式的字符串表示形式。
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/CallExpressionNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/CallExpressionNode.java
index ac36871..22f47bc 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/CallExpressionNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/CallExpressionNode.java
@@ -14,6 +14,7 @@ import java.util.List;
  * @param arguments 参数表达式列表，表示函数调用中传递给函数的实际参数。参数的顺序与调用顺序一致。
  * @param line      当前表达式所在的行号，方便调试和错误定位。
  * @param column    当前表达式所在的列号，用于精确定位错误位置。
+ * @param file      当前表达式所在的文件，用于错误定位。
  */
 public record CallExpressionNode(
         ExpressionNode callee,           // 被调用的表达式节点，表示函数或方法名
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/DeclarationNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/DeclarationNode.java
index 1819d1f..9e1edf5 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/DeclarationNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/DeclarationNode.java
@@ -23,6 +23,15 @@ public class DeclarationNode implements StatementNode {
     /** 可选的初始化表达式 */
     private final Optional<ExpressionNode> initializer;
 
+    /** 当前节点所在的行号 **/
+    private final int line;
+
+    /** 当前节点所在的列号 **/
+    private final int column;
+
+    /** 当前节点所在的文件 **/
+    private final String file;
+
     /**
      * 构造一个 {@code DeclarationNode} 实例。
      *
@@ -30,10 +39,13 @@ public class DeclarationNode implements StatementNode {
      * @param type        变量类型字符串（如 "int"、"string"）
      * @param initializer 可选初始化表达式，若为 {@code null} 表示未初始化
      */
-    public DeclarationNode(String name, String type, ExpressionNode initializer) {
+    public DeclarationNode(String name, String type, ExpressionNode initializer, int line, int column, String file) {
         this.name = name;
         this.type = type;
         this.initializer = Optional.ofNullable(initializer);
+        this.line = line;
+        this.column = column;
+        this.file = file;
     }
 
     /**
@@ -62,4 +74,29 @@ public class DeclarationNode implements StatementNode {
     public Optional<ExpressionNode> getInitializer() {
         return initializer;
     }
+
+    /**
+     * 获取当前表达式所在的行号。
+     *
+     * @return 当前表达式的行号。
+     */
+    public int line() {
+        return line;
+    }
+
+    /**
+     * 获取当前表达式所在的列号。
+     *
+     * @return 当前表达式的列号。
+     */
+    public int column() {
+        return column;
+    }
+
+    /**
+     * 获取当前表达式所在的文件名。
+     *
+     * @return 当前表达式所在的文件名。
+     */
+    public String file()   { return file;   }
 }
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/ExpressionStatementNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/ExpressionStatementNode.java
index cf62fb1..1a2f7a5 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/ExpressionStatementNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/ExpressionStatementNode.java
@@ -11,6 +11,14 @@ import org.jcnc.snow.compiler.parser.ast.base.StatementNode;
  * </p>
  *
  * @param expression 表达式主体，通常为函数调用、赋值、方法链式调用等可求值表达式。
+ * @param line     当前节点所在的行号
+ * @param column   当前节点所在的列号
+ * @param file     当前节点所在的文件
  */
-public record ExpressionStatementNode(ExpressionNode expression) implements StatementNode {
+public record ExpressionStatementNode(
+        ExpressionNode expression,
+        int line,
+        int column,
+        String file
+) implements StatementNode {
 }
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/FunctionNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/FunctionNode.java
index 7ab55dd..29ab884 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/FunctionNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/FunctionNode.java
@@ -17,7 +17,17 @@ import java.util.List;
  * @param parameters 参数列表，每项为 {@link ParameterNode} 表示一个形参定义
  * @param returnType 函数的返回类型（如 "int"、"void" 等）
  * @param body       函数体语句块，由一组 {@link StatementNode} 构成
+ * @param line     当前节点所在的行号
+ * @param column   当前节点所在的列号
+ * @param file     当前节点所在的文件
  */
-public record FunctionNode(String name, List<ParameterNode> parameters, String returnType,
-                           List<StatementNode> body) implements Node {
+public record FunctionNode(
+        String name,
+        List<ParameterNode> parameters,
+        String returnType,
+        List<StatementNode> body,
+        int line,
+        int column,
+        String file
+) implements Node {
 }
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/IdentifierNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/IdentifierNode.java
index cfce3d4..de0ed17 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/IdentifierNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/IdentifierNode.java
@@ -10,8 +10,16 @@ import org.jcnc.snow.compiler.parser.ast.base.ExpressionNode;
  * </p>
  *
  * @param name 标识符的文本名称（如变量名 "x"，函数名 "foo"）
+ * @param line     当前节点所在的行号
+ * @param column   当前节点所在的列号
+ * @param file     当前节点所在的文件
  */
-public record IdentifierNode(String name) implements ExpressionNode {
+public record IdentifierNode(
+        String name,
+        int line,
+        int column,
+        String file
+) implements ExpressionNode {
 
     /**
      * 返回标识符节点的字符串形式，通常为其名称本身。
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/IfNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/IfNode.java
index 9ac9371..a26c8e2 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/IfNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/IfNode.java
@@ -29,10 +29,16 @@ import java.util.List;
  * @param condition  控制分支执行的条件表达式
  * @param thenBranch 条件为 true 时执行的语句块
  * @param elseBranch 条件为 false 时执行的语句块（可为空）
+ * @param line     当前节点所在的行号
+ * @param column   当前节点所在的列号
+ * @param file     当前节点所在的文件
  */
 public record IfNode(
         ExpressionNode condition,
         List<StatementNode> thenBranch,
-        List<StatementNode> elseBranch
+        List<StatementNode> elseBranch,
+        int line,
+        int column,
+        String file
 ) implements StatementNode {
 }
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/ImportNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/ImportNode.java
index f551fd9..c6b65e9 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/ImportNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/ImportNode.java
@@ -14,6 +14,14 @@ import org.jcnc.snow.compiler.parser.ast.base.Node;
  * </p>
  *
  * @param moduleName 被导入的模块名称，通常为点分层次结构（如 "core.utils"）
+ * @param line     当前节点所在的行号
+ * @param column   当前节点所在的列号
+ * @param file     当前节点所在的文件
  */
-public record ImportNode(String moduleName) implements Node {
+public record ImportNode(
+        String moduleName,
+        int line,
+        int column,
+        String file
+) implements Node {
 }
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/LoopNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/LoopNode.java
index 7821ae4..a8ddbe1 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/LoopNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/LoopNode.java
@@ -17,7 +17,17 @@ import java.util.List;
  * @param condition   每次迭代前评估的条件表达式，控制循环是否继续
  * @param update      每轮迭代完成后执行的更新语句
  * @param body        循环体语句列表，表示循环主体执行逻辑
+ * @param line     当前节点所在的行号
+ * @param column   当前节点所在的列号
+ * @param file     当前节点所在的文件
  */
-public record LoopNode(StatementNode initializer, ExpressionNode condition, StatementNode update,
-                       List<StatementNode> body) implements StatementNode {
+public record LoopNode(
+        StatementNode initializer,
+        ExpressionNode condition,
+        StatementNode update,
+        List<StatementNode> body,
+        int line,
+        int column,
+        String file
+) implements StatementNode {
 }
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/MemberExpressionNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/MemberExpressionNode.java
index 7b49db3..d0ac38e 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/MemberExpressionNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/MemberExpressionNode.java
@@ -11,8 +11,17 @@ import org.jcnc.snow.compiler.parser.ast.base.ExpressionNode;
  *
  * @param object 左侧对象表达式，表示成员所属的作用域或容器
  * @param member 要访问的成员名称（字段名或方法名）
+ * @param line     当前节点所在的行号
+ * @param column   当前节点所在的列号
+ * @param file     当前节点所在的文件
  */
-public record MemberExpressionNode(ExpressionNode object, String member) implements ExpressionNode {
+public record MemberExpressionNode(
+        ExpressionNode object,
+        String member,
+        int line,
+        int column,
+        String file
+) implements ExpressionNode {
 
     /**
      * 返回成员访问表达式的字符串形式。
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/ModuleNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/ModuleNode.java
index 564402a..05d47de 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/ModuleNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/ModuleNode.java
@@ -13,8 +13,18 @@ import java.util.StringJoiner;
  * @param name      模块名称。
  * @param imports   模块导入列表，每个导入是一个 {@link ImportNode}。
  * @param functions 模块中的函数列表，每个函数是一个 {@link FunctionNode}。
+ * @param line     当前节点所在的行号
+ * @param column   当前节点所在的列号
+ * @param file     当前节点所在的文件
  */
-public record ModuleNode(String name, List<ImportNode> imports, List<FunctionNode> functions) implements Node {
+public record ModuleNode(
+        String name,
+        List<ImportNode> imports,
+        List<FunctionNode> functions,
+        int line,
+        int column,
+        String file
+) implements Node {
 
     /**
      * 返回模块节点的字符串表示形式，包含模块名、导入模块列表和函数列表。
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/ParameterNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/ParameterNode.java
index 91e93aa..0fbdc18 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/ParameterNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/ParameterNode.java
@@ -11,8 +11,17 @@ import org.jcnc.snow.compiler.parser.ast.base.Node;
  *
  * @param name 参数名称标识符
  * @param type 参数类型字符串（如 "int"、"string"）
+ * @param line     当前节点所在的行号
+ * @param column   当前节点所在的列号
+ * @param file     当前节点所在的文件
  */
-public record ParameterNode(String name, String type) implements Node {
+public record ParameterNode(
+        String name,
+        String type,
+        int line,
+        int column,
+        String file
+) implements Node {
 
     /**
      * 返回参数的字符串形式，格式为 {@code name:type}。
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/ReturnNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/ReturnNode.java
index 28143dd..0fc2254 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/ReturnNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/ReturnNode.java
@@ -23,13 +23,25 @@ public class ReturnNode implements StatementNode {
     /** 可选的返回值表达式 */
     private final Optional<ExpressionNode> expression;
 
+    /** 当前节点所在的行号 **/
+    private final int line;
+
+    /** 当前节点所在的列号 **/
+    private final int column;
+
+    /** 当前节点所在的文件 **/
+    private final String file;
+
     /**
      * 构造一个 {@code ReturnNode} 实例。
      *
      * @param expression 返回值表达式，如果无返回值则可为 {@code null}
      */
-    public ReturnNode(ExpressionNode expression) {
+    public ReturnNode(ExpressionNode expression, int line, int column, String file) {
         this.expression = Optional.ofNullable(expression);
+        this.line = line;
+        this.column = column;
+        this.file = file;
     }
 
     /**
@@ -40,4 +52,29 @@ public class ReturnNode implements StatementNode {
     public Optional<ExpressionNode> getExpression() {
         return expression;
     }
+
+    /**
+     * 获取当前表达式所在的行号。
+     *
+     * @return 当前表达式的行号。
+     */
+    public int line() {
+        return line;
+    }
+
+    /**
+     * 获取当前表达式所在的列号。
+     *
+     * @return 当前表达式的列号。
+     */
+    public int column() {
+        return column;
+    }
+
+    /**
+     * 获取当前表达式所在的文件名。
+     *
+     * @return 当前表达式所在的文件名。
+     */
+    public String file()   { return file;   }
 }
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/ast/UnaryExpressionNode.java b/src/main/java/org/jcnc/snow/compiler/parser/ast/UnaryExpressionNode.java
index d956fc8..7e38ebc 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/ast/UnaryExpressionNode.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/ast/UnaryExpressionNode.java
@@ -15,9 +15,17 @@ import org.jcnc.snow.compiler.parser.ast.base.ExpressionNode;
  *
  * @param operator 一元运算符（仅 "-" 或 "!"）
  * @param operand  运算对象 / 右操作数
+ * @param line     当前节点所在的行号
+ * @param column   当前节点所在的列号
+ * @param file     当前节点所在的文件
  */
-public record UnaryExpressionNode(String operator,
-                                  ExpressionNode operand) implements ExpressionNode {
+public record UnaryExpressionNode(
+        String operator,
+        ExpressionNode operand,
+        int line,
+        int column,
+        String file
+) implements ExpressionNode {
 
     /**
      * 生成调试友好的字符串表示，例如 {@code "-x"} 或 {@code "!flag"}。
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/expression/BinaryOperatorParselet.java b/src/main/java/org/jcnc/snow/compiler/parser/expression/BinaryOperatorParselet.java
index da86f01..adee8bd 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/expression/BinaryOperatorParselet.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/expression/BinaryOperatorParselet.java
@@ -37,6 +37,11 @@ public record BinaryOperatorParselet(Precedence precedence, boolean leftAssoc) i
      */
     @Override
     public ExpressionNode parse(ParserContext ctx, ExpressionNode left) {
+        // 获取当前 token 的行号、列号和文件名
+        int line = ctx.getTokens().peek().getLine();
+        int column = ctx.getTokens().peek().getCol();
+        String file = ctx.getSourceName();
+
         Token op = ctx.getTokens().next();
         int prec = precedence.ordinal();
 
@@ -46,7 +51,7 @@ public record BinaryOperatorParselet(Precedence precedence, boolean leftAssoc) i
                 leftAssoc ? Precedence.values()[prec] : Precedence.values()[prec - 1]
         );
 
-        return new BinaryExpressionNode(left, op.getLexeme(), right);
+        return new BinaryExpressionNode(left, op.getLexeme(), right, line, column, file);
     }
 
     /**
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/expression/CallParselet.java b/src/main/java/org/jcnc/snow/compiler/parser/expression/CallParselet.java
index 9499f6d..9f5478a 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/expression/CallParselet.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/expression/CallParselet.java
@@ -26,14 +26,15 @@ public class CallParselet implements InfixParselet {
      */
     @Override
     public ExpressionNode parse(ParserContext ctx, ExpressionNode left) {
+        // 获取函数名 token 的行号、列号和文件名
+        int line = ctx.getTokens().peek(-1).getLine();
+        int column = ctx.getTokens().peek(-1).getCol();
+        String file = ctx.getSourceName();
+
         ctx.getTokens().next(); // 消费 "("
 
         List<ExpressionNode> args = new ArrayList<>();
 
-        // 获取当前 token 的行号和列号
-        int line = ctx.getTokens().peek().getLine();
-        int column = ctx.getTokens().peek().getCol();
-
         // 解析函数调用参数
         if (!ctx.getTokens().peek().getLexeme().equals(")")) {
             do {
@@ -43,8 +44,7 @@ public class CallParselet implements InfixParselet {
 
         ctx.getTokens().expect(")"); // 消费并验证 ")"
 
-        // 创建 CallExpressionNode 并传递位置信息,文件名称
-        String file = ctx.getSourceName();
+        // 创建 CallExpressionNode 并传递位置信息
         return new CallExpressionNode(left, args, line, column, file);
     }
 
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/expression/IdentifierParselet.java b/src/main/java/org/jcnc/snow/compiler/parser/expression/IdentifierParselet.java
index 057c425..7e46337 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/expression/IdentifierParselet.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/expression/IdentifierParselet.java
@@ -24,6 +24,11 @@ public class IdentifierParselet implements PrefixParselet {
      */
     @Override
     public ExpressionNode parse(ParserContext ctx, Token token) {
-        return new IdentifierNode(token.getLexeme());
+        // 获取标识符 token 的行号、列号和文件名
+        int line = ctx.getTokens().peek(-1).getLine();
+        int column = ctx.getTokens().peek(-1).getCol();
+        String file = ctx.getSourceName();
+
+        return new IdentifierNode(token.getLexeme(), line, column, file);
     }
 }
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/expression/MemberParselet.java b/src/main/java/org/jcnc/snow/compiler/parser/expression/MemberParselet.java
index b0f1e5f..ed3cd58 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/expression/MemberParselet.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/expression/MemberParselet.java
@@ -28,8 +28,13 @@ public class MemberParselet implements InfixParselet {
         TokenStream ts = ctx.getTokens();
         ts.expect("."); // 消费点号
 
+        // 获取当前 token 的行号、列号和文件名
+        int line = ctx.getTokens().peek().getLine();
+        int column = ctx.getTokens().peek().getCol();
+        String file = ctx.getSourceName();
+
         String member = ts.expectType(TokenType.IDENTIFIER).getLexeme();
-        return new MemberExpressionNode(left, member);
+        return new MemberExpressionNode(left, member, line, column, file);
     }
 
     /**
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/expression/UnaryOperatorParselet.java b/src/main/java/org/jcnc/snow/compiler/parser/expression/UnaryOperatorParselet.java
index abfa97a..5aedf93 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/expression/UnaryOperatorParselet.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/expression/UnaryOperatorParselet.java
@@ -41,6 +41,11 @@ public class UnaryOperatorParselet implements PrefixParselet {
      */
     @Override
     public ExpressionNode parse(ParserContext ctx, Token token) {
+        // 获取当前 token 的行号、列号和文件名
+        int line = ctx.getTokens().peek().getLine();
+        int column = ctx.getTokens().peek().getCol();
+        String file = ctx.getSourceName();
+
         /* ------------------------------------------------------------
          * 1. 以 UNARY 优先级递归解析操作数，避免错误结合顺序。
          * ------------------------------------------------------------ */
@@ -50,6 +55,6 @@ public class UnaryOperatorParselet implements PrefixParselet {
         /* ------------------------------------------------------------
          * 2. 封装成 AST 节点并返回。
          * ------------------------------------------------------------ */
-        return new UnaryExpressionNode(token.getLexeme(), operand);
+        return new UnaryExpressionNode(token.getLexeme(), operand, line, column, file);
     }
 }
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/function/ASTPrinter.java b/src/main/java/org/jcnc/snow/compiler/parser/function/ASTPrinter.java
index 65bf0c0..a45ea72 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/function/ASTPrinter.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/function/ASTPrinter.java
@@ -67,6 +67,7 @@ public class ASTPrinter {
             }
             case FunctionNode(
                     String name, List<ParameterNode> parameters, String returnType, List<StatementNode> body
+                    , _, _, _
             ) -> {
                 System.out.println(pad + "function " + name
                         + "(params=" + parameters + ", return=" + returnType + ")");
@@ -81,9 +82,12 @@ public class ASTPrinter {
                         .orElse("");
                 System.out.println(pad + "declare " + d.getName() + ":" + d.getType() + init);
             }
-            case AssignmentNode(String variable, ExpressionNode value) ->
+            case AssignmentNode(String variable, ExpressionNode value, _, int _, String _) ->
                     System.out.println(pad + variable + " = " + value);
-            case IfNode(ExpressionNode condition, List<StatementNode> thenBranch, List<StatementNode> elseBranch) -> {
+            case IfNode(
+                    ExpressionNode condition, List<StatementNode> thenBranch, List<StatementNode> elseBranch, int _,
+                    int _, String _
+            ) -> {
                 System.out.println(pad + "if " + condition);
                 for (StatementNode stmt : thenBranch) {
                     print(stmt, indent + 1);
@@ -97,6 +101,7 @@ public class ASTPrinter {
             }
             case LoopNode(
                     StatementNode initializer, ExpressionNode condition, StatementNode update, List<StatementNode> body
+                    , int _, int _, String _
             ) -> {
                 System.out.println(pad + "loop {");
                 print(initializer, indent + 1);
@@ -111,10 +116,9 @@ public class ASTPrinter {
             }
             case ReturnNode r -> System.out.println(pad + "return" +
                     r.getExpression().map(e -> " " + e).orElse(""));
-            case ExpressionStatementNode(ExpressionNode expression) ->
+            case ExpressionStatementNode(ExpressionNode expression, int _, int _, String _) ->
                     System.out.println(pad + expression);
-            case null, default ->
-                    System.out.println(pad + n);  // 回退处理
+            case null, default -> System.out.println(pad + n);  // 回退处理
         }
     }
 
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/function/FunctionParser.java b/src/main/java/org/jcnc/snow/compiler/parser/function/FunctionParser.java
index af2251e..a7a3449 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/function/FunctionParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/function/FunctionParser.java
@@ -57,6 +57,11 @@ public class FunctionParser implements TopLevelParser {
     public FunctionNode parse(ParserContext ctx) {
         TokenStream ts = ctx.getTokens();
 
+        // 获取当前 token 的行号、列号和文件名
+        int line = ctx.getTokens().peek().getLine();
+        int column = ctx.getTokens().peek().getCol();
+        String file = ctx.getSourceName();
+
         parseFunctionHeader(ts);
         String functionName = parseFunctionName(ts);
 
@@ -69,7 +74,7 @@ public class FunctionParser implements TopLevelParser {
 
         parseFunctionFooter(ts);
 
-        return new FunctionNode(functionName, parameters, returnType[0], body);
+        return new FunctionNode(functionName, parameters, returnType[0], body, line, column, file);
     }
 
     /**
@@ -92,7 +97,7 @@ public class FunctionParser implements TopLevelParser {
 
         map.put("parameter", new SectionDefinition(
                 (TokenStream stream) -> stream.peek().getLexeme().equals("parameter"),
-                (ParserContext context, TokenStream stream) -> params.addAll(parseParameters(stream))
+                (ParserContext context, TokenStream stream) -> params.addAll(parseParameters(context))
         ));
 
         map.put("return_type", new SectionDefinition(
@@ -154,10 +159,12 @@ public class FunctionParser implements TopLevelParser {
      * </pre>
      * </p>
      *
-     * @param ts 当前使用的 {@link TokenStream}。
+     * @param ctx 当前解析上下文，包含 {@link TokenStream} 和符号表等作用域信息。
      * @return 所有参数节点的列表。
      */
-    private List<ParameterNode> parseParameters(TokenStream ts) {
+    private List<ParameterNode> parseParameters(ParserContext ctx) {
+        TokenStream ts = ctx.getTokens();
+
         ts.expect("parameter");
         ts.expect(":");
         skipComments(ts);
@@ -175,13 +182,19 @@ public class FunctionParser implements TopLevelParser {
             if (lex.equals("return_type") || lex.equals("body") || lex.equals("end")) {
                 break;
             }
+
+            // 获取当前 token 的行号、列号和文件名
+            int line = ctx.getTokens().peek().getLine();
+            int column = ctx.getTokens().peek().getCol();
+            String file = ctx.getSourceName();
+
             ts.expect("declare");
             String pname = ts.expectType(TokenType.IDENTIFIER).getLexeme();
             ts.expect(":");
             String ptype = ts.expectType(TokenType.TYPE).getLexeme();
             skipComments(ts);
             ts.expectType(TokenType.NEWLINE);
-            list.add(new ParameterNode(pname, ptype));
+            list.add(new ParameterNode(pname, ptype, line, column, file));
         }
         return list;
     }
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/module/ImportParser.java b/src/main/java/org/jcnc/snow/compiler/parser/module/ImportParser.java
index 38dd788..d5443ac 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/module/ImportParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/module/ImportParser.java
@@ -46,13 +46,18 @@ public class ImportParser {
 
         // 解析一个或多个模块名（标识符），允许使用逗号分隔多个模块
         do {
+            // 获取当前 token 的行号、列号和文件名
+            int line = ctx.getTokens().peek().getLine();
+            int column = ctx.getTokens().peek().getCol();
+            String file = ctx.getSourceName();
+
             // 获取当前标识符类型的词法单元，并提取其原始词素
             String mod = ctx.getTokens()
                     .expectType(TokenType.IDENTIFIER)
                     .getLexeme();
 
             // 创建 ImportNode 节点并加入列表
-            imports.add(new ImportNode(mod));
+            imports.add(new ImportNode(mod, line, column, file));
         } while (ctx.getTokens().match(",")); // 如果匹配到逗号，继续解析下一个模块名
 
         // 最后必须匹配换行符，标志 import 语句的结束
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/module/ModuleParser.java b/src/main/java/org/jcnc/snow/compiler/parser/module/ModuleParser.java
index b696410..ac9e05d 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/module/ModuleParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/module/ModuleParser.java
@@ -40,6 +40,11 @@ public class ModuleParser implements TopLevelParser {
         // 获取当前上下文中提供的词法流
         TokenStream ts = ctx.getTokens();
 
+        // 获取当前 token 的行号、列号和文件名
+        int line = ctx.getTokens().peek().getLine();
+        int column = ctx.getTokens().peek().getCol();
+        String file = ctx.getSourceName();
+
         // 期望模块声明以关键字 "module:" 开始
         ts.expect("module");
         ts.expect(":");
@@ -90,6 +95,6 @@ public class ModuleParser implements TopLevelParser {
         ts.expect("module");
 
         // 构建并返回完整的模块语法树节点
-        return new ModuleNode(name, imports, functions);
+        return new ModuleNode(name, imports, functions, line, column, file);
     }
 }
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/statement/DeclarationStatementParser.java b/src/main/java/org/jcnc/snow/compiler/parser/statement/DeclarationStatementParser.java
index b99d09c..2323ada 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/statement/DeclarationStatementParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/statement/DeclarationStatementParser.java
@@ -43,6 +43,11 @@ public class DeclarationStatementParser implements StatementParser {
      */
     @Override
     public DeclarationNode parse(ParserContext ctx) {
+        // 获取当前 token 的行号、列号和文件名
+        int line = ctx.getTokens().peek().getLine();
+        int column = ctx.getTokens().peek().getCol();
+        String file = ctx.getSourceName();
+
         // 声明语句必须以 "declare" 开头
         ctx.getTokens().expect("declare");
 
@@ -69,6 +74,6 @@ public class DeclarationStatementParser implements StatementParser {
         ctx.getTokens().expectType(TokenType.NEWLINE);
 
         // 返回构建好的声明语法树节点
-        return new DeclarationNode(name, type, init);
+        return new DeclarationNode(name, type, init, line, column, file);
     }
 }
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/statement/ExpressionStatementParser.java b/src/main/java/org/jcnc/snow/compiler/parser/statement/ExpressionStatementParser.java
index dd9df94..526dbf0 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/statement/ExpressionStatementParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/statement/ExpressionStatementParser.java
@@ -50,6 +50,11 @@ public class ExpressionStatementParser implements StatementParser {
             throw new IllegalStateException("Cannot parse expression starting with keyword: " + ts.peek().getLexeme());
         }
 
+        // 获取当前 token 的行号、列号和文件名
+        int line = ctx.getTokens().peek().getLine();
+        int column = ctx.getTokens().peek().getCol();
+        String file = ctx.getSourceName();
+
         // 处理赋值语句：格式为 identifier = expression
         if (ts.peek().getType() == TokenType.IDENTIFIER
                 && ts.peek(1).getLexeme().equals("=")) {
@@ -58,13 +63,13 @@ public class ExpressionStatementParser implements StatementParser {
             ts.expect("=");                         // 消耗等号
             ExpressionNode value = new PrattExpressionParser().parse(ctx); // 解析表达式
             ts.expectType(TokenType.NEWLINE);       // 语句必须以换行符结束
-            return new AssignmentNode(varName, value); // 返回赋值节点
+            return new AssignmentNode(varName, value, line, column, file); // 返回赋值节点
         }
 
         // 处理普通表达式语句，如函数调用、字面量、运算表达式等
         ExpressionNode expr = new PrattExpressionParser().parse(ctx);
         ts.expectType(TokenType.NEWLINE);           // 语句必须以换行符结束
-        return new ExpressionStatementNode(expr);   // 返回表达式语句节点
+        return new ExpressionStatementNode(expr, line, column, file);   // 返回表达式语句节点
     }
 
 }
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/statement/IfStatementParser.java b/src/main/java/org/jcnc/snow/compiler/parser/statement/IfStatementParser.java
index f0e2498..eda8bb1 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/statement/IfStatementParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/statement/IfStatementParser.java
@@ -47,6 +47,11 @@ public class IfStatementParser implements StatementParser {
     public IfNode parse(ParserContext ctx) {
         var ts = ctx.getTokens(); // 获取 token 流引用
 
+        // 获取当前 token 的行号、列号和文件名
+        int line = ctx.getTokens().peek().getLine();
+        int column = ctx.getTokens().peek().getCol();
+        String file = ctx.getSourceName();
+
         // 消耗起始关键字 "if"
         ts.expect("if");
 
@@ -120,6 +125,6 @@ public class IfStatementParser implements StatementParser {
         ts.expectType(TokenType.NEWLINE);
 
         // 构建并返回 IfNode，包含条件、then 分支和 else 分支
-        return new IfNode(condition, thenBranch, elseBranch);
+        return new IfNode(condition, thenBranch, elseBranch, line, column, file);
     }
 }
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/statement/LoopStatementParser.java b/src/main/java/org/jcnc/snow/compiler/parser/statement/LoopStatementParser.java
index 583b5c9..4422636 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/statement/LoopStatementParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/statement/LoopStatementParser.java
@@ -64,6 +64,12 @@ public class LoopStatementParser implements StatementParser {
     public LoopNode parse(ParserContext ctx) {
         TokenStream ts = ctx.getTokens();
 
+        // 获取当前 token 的行号、列号
+        int loop_line = ctx.getTokens().peek().getLine();
+        int loop_column = ctx.getTokens().peek().getCol();
+
+        String file = ctx.getSourceName();
+
         // 匹配 loop: 起始语法
         ParserUtils.matchHeader(ts, "loop");
 
@@ -101,12 +107,16 @@ public class LoopStatementParser implements StatementParser {
         sections.put("update", new FlexibleSectionParser.SectionDefinition(
                 ts1 -> ts1.peek().getLexeme().equals("update"),
                 (ctx1, ts1) -> {
+                    // 获取当前 token 的行号、列号
+                    int line = ctx.getTokens().peek().getLine();
+                    int column = ctx.getTokens().peek().getCol();
+
                     ParserUtils.matchHeader(ts1, "update");
                     String varName = ts1.expectType(TokenType.IDENTIFIER).getLexeme();
                     ts1.expect("=");
                     ExpressionNode expr = new PrattExpressionParser().parse(ctx1);
                     ts1.expectType(TokenType.NEWLINE);
-                    update[0] = new AssignmentNode(varName, expr);
+                    update[0] = new AssignmentNode(varName, expr, line, column, file);
                     ParserUtils.skipNewlines(ts1);
                 }
         ));
@@ -140,6 +150,6 @@ public class LoopStatementParser implements StatementParser {
         ParserUtils.matchFooter(ts, "loop");
 
         // 返回构造完成的 LoopNode
-        return new LoopNode(initializer[0], condition[0], update[0], body);
+        return new LoopNode(initializer[0], condition[0], update[0], body, loop_line, loop_column, file);
     }
 }
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/statement/ReturnStatementParser.java b/src/main/java/org/jcnc/snow/compiler/parser/statement/ReturnStatementParser.java
index 8a6a6a2..080f1e6 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/statement/ReturnStatementParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/statement/ReturnStatementParser.java
@@ -35,6 +35,11 @@ public class ReturnStatementParser implements StatementParser {
      */
     @Override
     public ReturnNode parse(ParserContext ctx) {
+        // 获取当前 token 的行号、列号和文件名
+        int line = ctx.getTokens().peek().getLine();
+        int column = ctx.getTokens().peek().getCol();
+        String file = ctx.getSourceName();
+
         // 消耗 "return" 关键字
         ctx.getTokens().expect("return");
 
@@ -49,6 +54,6 @@ public class ReturnStatementParser implements StatementParser {
         ctx.getTokens().expectType(TokenType.NEWLINE);
 
         // 构建并返回 ReturnNode（可能为空表达式）
-        return new ReturnNode(expr);
+        return new ReturnNode(expr, line, column, file);
     }
 }
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/utils/ASTJsonSerializer.java b/src/main/java/org/jcnc/snow/compiler/parser/utils/ASTJsonSerializer.java
index aec4b50..db65294 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/utils/ASTJsonSerializer.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/utils/ASTJsonSerializer.java
@@ -81,7 +81,10 @@ public class ASTJsonSerializer {
     private static Object nodeToMap(Node n) {
         return switch (n) {
             // 模块节点
-            case ModuleNode(String name, List<ImportNode> imports, List<FunctionNode> functions) -> {
+            case ModuleNode(
+                    String name, List<ImportNode> imports, List<FunctionNode> functions, _, int _,
+                    String _
+            ) -> {
                 Map<String, Object> map = newNodeMap("Module");
                 map.put("name", name);
                 List<Object> imps = new ArrayList<>(imports.size());
@@ -177,20 +180,23 @@ public class ASTJsonSerializer {
     private static Object exprToMap(ExpressionNode expr) {
         return switch (expr) {
             // 二元表达式
-            case BinaryExpressionNode(ExpressionNode left, String operator, ExpressionNode right) -> exprMap("BinaryExpression",
+            case BinaryExpressionNode(
+                    ExpressionNode left, String operator, ExpressionNode right, int _, int _, String _
+            ) -> exprMap("BinaryExpression",
                     "left", exprToMap(left),
                     "operator", operator,
                     "right", exprToMap(right)
             );
             // 一元表达式
-            case UnaryExpressionNode(String operator, ExpressionNode operand) -> exprMap("UnaryExpression",
-                    "operator", operator,
-                    "operand", exprToMap(operand)
-            );
+            case UnaryExpressionNode(String operator, ExpressionNode operand, int _, int _, String _) ->
+                    exprMap("UnaryExpression",
+                            "operator", operator,
+                            "operand", exprToMap(operand)
+                    );
             // 布尔字面量
             case BoolLiteralNode(boolean value) -> exprMap("BoolLiteral", "value", value);
             // 标识符
-            case IdentifierNode(String name) -> exprMap("Identifier", "name", name);
+            case IdentifierNode(String name, int _, int _, String _) -> exprMap("Identifier", "name", name);
             // 数字字面量
             case NumberLiteralNode(String value) -> exprMap("NumberLiteral", "value", value);
             // 字符串字面量
@@ -202,10 +208,11 @@ public class ASTJsonSerializer {
                 yield exprMap("CallExpression", "callee", exprToMap(callee), "arguments", args);
             }
             // 成员访问表达式
-            case MemberExpressionNode(ExpressionNode object, String member) -> exprMap("MemberExpression",
-                    "object", exprToMap(object),
-                    "member", member
-            );
+            case MemberExpressionNode(ExpressionNode object, String member, int _, int _, String _) ->
+                    exprMap("MemberExpression",
+                            "object", exprToMap(object),
+                            "member", member
+                    );
             // 默认兜底处理：只写类型
             default -> Map.of("type", expr.getClass().getSimpleName());
         };
diff --git a/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/BinaryExpressionAnalyzer.java b/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/BinaryExpressionAnalyzer.java
index 2bc22de..c14b83b 100644
--- a/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/BinaryExpressionAnalyzer.java
+++ b/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/BinaryExpressionAnalyzer.java
@@ -11,79 +11,75 @@ import org.jcnc.snow.compiler.semantic.type.BuiltinType;
 import org.jcnc.snow.compiler.semantic.type.Type;
 
 /**
- * {@code BinaryExpressionAnalyzer} 是一个用于分析二元表达式的语义分析器。
+ * {@code BinaryExpressionAnalyzer} 负责对二元表达式做语义分析并返回其类型。
  * <p>
- * 支持的特性包括：
- * <ul>
- *     <li>字符串拼接（当运算符为加号 "+" 且任一操作数为字符串类型时）</li>
- *     <li>数值类型的自动宽化转换（如 int 与 float 运算将转换为 float）</li>
- *     <li>基本的数值运算符（如 +, -, *, /, %）</li>
- *     <li>关系运算符和比较运算符（如 <, <=, >, >=, ==, !=）</li>
- * </ul>
- * 对于不支持的运算符或不兼容的类型组合，将记录语义错误，并默认返回 {@code BuiltinType.INT} 以保持分析过程的连续性。
+ * 支持特性：
+ * 1. 字符串拼接「+」
+ * 2. 数值运算与自动宽化
+ * 3. 比较 / 关系运算
+ * 4. 布尔值比较（== / !=）
  * <p>
- * 实现类遵循 {@code ExpressionAnalyzer<BinaryExpressionNode>} 接口规范。
+ * 如遇不支持的运算符或不兼容的类型组合，将记录语义错误，
+ * 并以 {@code int} 作为回退类型，保持后续分析不中断。
  */
 public class BinaryExpressionAnalyzer implements ExpressionAnalyzer<BinaryExpressionNode> {
 
-    /**
-     * 分析给定的二元表达式节点，返回其表达式类型。
-     *
-     * @param ctx    当前语义分析上下文，用于访问日志记录、错误收集、注册表等服务。
-     * @param mi     当前模块信息，包含模块级别的符号与类型定义。
-     * @param fn     当前正在分析的函数节点。
-     * @param locals 当前函数作用域内的符号表，用于变量查找。
-     * @param bin    要分析的二元表达式节点。
-     * @return 分析后推断出的表达式类型。
-     */
     @Override
     public Type analyze(Context ctx,
                         ModuleInfo mi,
                         FunctionNode fn,
                         SymbolTable locals,
                         BinaryExpressionNode bin) {
+
         ctx.log("检查二元表达式: " + bin.operator());
 
-        // 获取左侧表达式类型
-        Type left = ctx.getRegistry().getExpressionAnalyzer(bin.left())
+        /* ----------- 先递归分析左右子表达式类型 ----------- */
+        Type left  = ctx.getRegistry()
+                .getExpressionAnalyzer(bin.left())
                 .analyze(ctx, mi, fn, locals, bin.left());
 
-        // 获取右侧表达式类型
-        Type right = ctx.getRegistry().getExpressionAnalyzer(bin.right())
+        Type right = ctx.getRegistry()
+                .getExpressionAnalyzer(bin.right())
                 .analyze(ctx, mi, fn, locals, bin.right());
 
         String op = bin.operator();
 
-        // 情况 1：字符串拼接（+ 操作符且任一操作数为字符串类型）
+        /* ----------- 情况 1：字符串拼接 ----------- */
         if (op.equals("+") &&
                 (left == BuiltinType.STRING || right == BuiltinType.STRING)) {
             return BuiltinType.STRING;
         }
 
-        // 情况 2：数值类型运算或比较
+        /* ----------- 情况 1.5：布尔值比较 ----------- */
+        if (("==".equals(op) || "!=".equals(op)) &&
+                left == BuiltinType.BOOLEAN &&
+                right == BuiltinType.BOOLEAN) {
+            return BuiltinType.BOOLEAN;
+        }
+
+        /* ----------- 情况 2：数值运算 / 比较 ----------- */
         if ("+-*/%".contains(op) || ("<<=>>===!=").contains(op)) {
             if (left.isNumeric() && right.isNumeric()) {
-                // 自动宽化到更宽的数值类型（如 int + float => float）
+                // 自动数值宽化（如 int + float → float）
                 Type wide = Type.widen(left, right);
-                if (wide == null) wide = BuiltinType.INT; // 容错降级为 int
+                if (wide == null) wide = BuiltinType.INT;   // 容错降级
 
-                // 若为比较运算符，统一返回 boolean 类型作为布尔值表示
+                // 比较运算统一返回 boolean
                 if ("< <= > >= == !=".contains(op)) {
                     return BuiltinType.BOOLEAN;
                 }
-
                 return wide;
             }
         }
 
-        // 情况 3：不支持的类型组合，记录语义错误
+        /* ----------- 情况 3：不支持的类型组合 ----------- */
         ctx.getErrors().add(new SemanticError(
                 bin,
                 String.format("运算符 '%s' 不支持类型: %s 和 %s", op, left, right)
         ));
         ctx.log("错误: 运算符 '" + op + "' 不支持类型: " + left + ", " + right);
 
-        // 错误情况下默认返回 int 类型，以保证语义分析不中断
+        // 回退类型
         return BuiltinType.INT;
     }
 }
diff --git a/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/CallExpressionAnalyzer.java b/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/CallExpressionAnalyzer.java
index b82d78f..9a6f923 100644
--- a/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/CallExpressionAnalyzer.java
+++ b/src/main/java/org/jcnc/snow/compiler/semantic/analyzers/expression/CallExpressionAnalyzer.java
@@ -51,8 +51,8 @@ public class CallExpressionAnalyzer implements ExpressionAnalyzer<CallExpression
         ExpressionNode callee = call.callee();
 
         // 支持模块调用形式：ModuleName.FunctionName(...)
-        if (callee instanceof MemberExpressionNode(var obj, String member)
-                && obj instanceof IdentifierNode(String mod)) {
+        if (callee instanceof MemberExpressionNode(var obj, String member, _, _, _)
+                && obj instanceof IdentifierNode(String mod, _, _, _)) {
             // 验证模块是否存在并已导入
             if (!ctx.getModules().containsKey(mod)
                     || (!mi.getImports().contains(mod) && !mi.getName().equals(mod))) {
@@ -65,7 +65,7 @@ public class CallExpressionAnalyzer implements ExpressionAnalyzer<CallExpression
             functionName = member;
 
             // 简单函数名形式：func(...)
-        } else if (callee instanceof IdentifierNode(String name)) {
+        } else if (callee instanceof IdentifierNode(String name, _, _, _)) {
             functionName = name;
 
             // 不支持的 callee 形式
diff --git a/src/main/java/org/jcnc/snow/pkg/doc/README.md b/src/main/java/org/jcnc/snow/pkg/doc/README.md
new file mode 100644
index 0000000..ec50ed5
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/doc/README.md
@@ -0,0 +1,64 @@
+# Snow Build - 包管理模块
+
+> Snow 构建工具中的 **pkg** 子系统 —— 负责解析 `.cloud` 配置、解析依赖、 orchestrate 构建生命周期并执行各阶段任务
+
+## 项目简介
+
+**包管理模块（pkg）** 是 Snow 构建工具的关键组成部分，承担“从配置到产物” 的整条流水线：
+
+1. **DSL 解析**：读取并解析 `.cloud` 配置文件，生成统一的项目/依赖/构建配置模型；
+2. **生命周期编排**：按 *INIT → RESOLVE\_DEPENDENCIES → COMPILE → PACKAGE → PUBLISH → CLEAN* 的顺序驱动构建流程；
+3. **依赖解析与缓存**：按需下载缺失依赖并存入本地缓存，离线优先；
+4. **任务执行**：在各生命周期阶段调用对应 `Task` 实现（清理、编译、打包、发布等）；
+5. **配置模板展开**：支持在配置中使用 `@{key}` 形式的占位符，并在构建前统一替换。
+
+整个模块强调 **可扩展性** 与 **内聚职责**：DSL → Model、Lifecycle → Task、Resolver → Repository 各自解耦，可独立演进。
+
+## 核心功能
+
+| 功能              | 关键类                                                      | 说明                                              |
+|-----------------|----------------------------------------------------------|-------------------------------------------------|
+| **CloudDSL 解析** | `CloudDSLParser`                                         | 支持区块语法、嵌套 build 展平、注释过滤，解析为扁平 `Map`             |
+| **模型对象**        | `Project / Dependency / Repository / BuildConfiguration` | 只读数据类，提供静态工厂方法 *fromFlatMap()*                  |
+| **生命周期管理**      | `LifecycleManager`, `LifecyclePhase`                     | 注册并顺序执行阶段任务，阶段可扩展                               |
+| **任务体系**        | `Task` + `*Task` 实现                                      | Clean / Compile / Package / Publish 四大内置任务，易于新增 |
+| **依赖解析器**       | `DependencyResolver`                                     | 支持本地缓存、HTTP 下载、URI 解析、断点续传（基于 NIO）              |
+| **模板变量替换**      | `BuildConfiguration`                                     | 在加载阶段把 `@{key}` 替换为外部属性值                        |
+
+## 模块结构
+
+```
+pkg/
+  ├── dsl/
+  │   └── CloudDSLParser.java        // .cloud DSL 解析
+  ├── lifecycle/
+  │   ├── LifecycleManager.java      // 阶段编排
+  │   └── LifecyclePhase.java        // 阶段枚举
+  ├── model/
+  │   ├── Project.java               // 项目信息
+  │   ├── BuildConfiguration.java    // 构建配置（支持变量）
+  │   ├── Dependency.java            // 依赖描述
+  │   └── Repository.java            // 仓库描述
+  ├── resolver/
+  │   └── DependencyResolver.java    // 依赖解析与缓存
+  └── tasks/
+      ├── Task.java                  // 任务接口
+      ├── CleanTask.java             // 清理
+      ├── CompileTask.java           // 编译
+      ├── PackageTask.java           // 打包
+      └── PublishTask.java           // 发布
+```
+
+## 典型流程概览
+
+1. 解析配置
+
+2. 注册任务并执行
+
+3. 解析依赖（在 RESOLVE\_DEPENDENCIES 阶段内部）
+
+## 开发环境
+
+* JDK 24 或更高版本
+* Maven 构建管理
+* 推荐 IDE：IntelliJ IDEA
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/pkg/dsl/CloudDSLParser.java b/src/main/java/org/jcnc/snow/pkg/dsl/CloudDSLParser.java
new file mode 100644
index 0000000..301e11d
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/dsl/CloudDSLParser.java
@@ -0,0 +1,139 @@
+package org.jcnc.snow.pkg.dsl;
+
+import org.jcnc.snow.pkg.model.Project;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * CloudDSL 配置文件解析器。
+ * <p>
+ * 负责将自定义的 .cloud 构建配置文件解析为 {@link Project} 模型。
+ * </p>
+ *
+ * <ul>
+ *   <li>顶级区块（如 project、properties、repositories、dependencies、build）以 <code>sectionName &#123;</code> 开始，以 <code>&#125;</code> 结束</li>
+ *   <li>区块内部只识别 <code>key = value</code> 赋值，行尾可有 <code># 注释</code></li>
+ *   <li>build 区块支持嵌套，内部键通过 <code>.</code> 展平，例如 <code>compile.enabled = true</code></li>
+ *   <li><strong>新增：</strong>对 <code>"value"</code> 或 <code>'value'</code> 形式的字面量自动去引号，调用方得到的均是不含引号的裸字符串</li>
+ * </ul>
+ *
+ * <pre>
+ * 示例 .cloud 文件片段：
+ * project {
+ *   group = com.example
+ *   artifact = "demo-app"
+ *   version = 1.0.0
+ * }
+ * </pre>
+ */
+public final class CloudDSLParser {
+
+    /** 匹配 sectionName { 的行 */
+    private static final Pattern SECTION_HEADER = Pattern.compile("^(\\w+)\\s*\\{\\s*$");
+
+    /**
+     * 匹配 key = value 行，忽略行尾注释。
+     * 使用非贪婪匹配 <code>.*?</code>，确保 <code>value</code> 内部允许出现空格或 =。
+     */
+    private static final Pattern KEY_VALUE = Pattern.compile("^(\\w+)\\s*=\\s*(.*?)\\s*(?:#.*)?$");
+
+    /** 匹配仅为 } 的行 */
+    private static final Pattern BLOCK_END = Pattern.compile("^}\\s*$");
+
+    /** 工具类禁止实例化 */
+    private CloudDSLParser() {}
+
+    /**
+     * 解析指定 .cloud 文件为 {@link Project} 对象。
+     * <ul>
+     *   <li>遇到语法错误（括号不配对、无法识别的行）时抛出异常</li>
+     *   <li>支持嵌套区块和注释</li>
+     *   <li>对字面量自动去除成对单/双引号</li>
+     * </ul>
+     *
+     * @param path .cloud 文件路径
+     * @return 解析得到的 Project 实例
+     * @throws IOException           文件读取失败
+     * @throws IllegalStateException 文件内容格式非法或语法错误
+     */
+    public static Project parse(Path path) throws IOException {
+
+        Deque<String> sectionStack = new ArrayDeque<>();       // 当前区块栈
+        Map<String, String> flatMap = new LinkedHashMap<>();   // 扁平化后的 key → value
+
+        List<String> lines = Files.readAllLines(path);
+
+        int lineNo = 0;
+        for (String raw : lines) {
+            lineNo++;
+            String line = raw.trim();
+
+            // 跳过空行和注释
+            if (line.isEmpty() || line.startsWith("#")) {
+                continue;
+            }
+
+            // 区块起始
+            Matcher sec = SECTION_HEADER.matcher(line);
+            if (sec.matches()) {
+                sectionStack.push(sec.group(1));
+                continue;
+            }
+
+            // 区块结束
+            if (BLOCK_END.matcher(line).matches()) {
+                if (sectionStack.isEmpty()) {
+                    throw new IllegalStateException("第 " + lineNo + " 行出现未配对的 '}'");
+                }
+                sectionStack.pop();
+                continue;
+            }
+
+            // 键值对
+            Matcher kv = KEY_VALUE.matcher(line);
+            if (kv.matches()) {
+                String key = kv.group(1).trim();
+                String value = kv.group(2).trim();
+                value = unquote(value);                    // 去除首尾成对引号
+
+                // 计算区块前缀
+                String prefix = String.join(".", (Iterable<String>) sectionStack::descendingIterator);
+                if (!prefix.isEmpty()) {
+                    key = prefix + "." + key;
+                }
+
+                flatMap.put(key, value);
+                continue;
+            }
+
+            // 无法识别的行
+            throw new IllegalStateException("无法解析第 " + lineNo + " 行: " + raw);
+        }
+
+        // 检查区块是否全部闭合
+        if (!sectionStack.isEmpty()) {
+            throw new IllegalStateException("文件结束但区块未闭合：" + sectionStack);
+        }
+
+        // 构建 Project 模型
+        return Project.fromFlatMap(flatMap);
+    }
+
+    /**
+     * 如果字符串首尾包裹成对单引号或双引号，则去掉引号后返回；否则直接返回原字符串。
+     */
+    private static String unquote(String s) {
+        if (s == null || s.length() < 2) return s;
+        char first = s.charAt(0);
+        char last  = s.charAt(s.length() - 1);
+        if ((first == '"' && last == '"') || (first == '\'' && last == '\'')) {
+            return s.substring(1, s.length() - 1);
+        }
+        return s;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/pkg/lifecycle/LifecycleManager.java b/src/main/java/org/jcnc/snow/pkg/lifecycle/LifecycleManager.java
new file mode 100644
index 0000000..6c1b5db
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/lifecycle/LifecycleManager.java
@@ -0,0 +1,64 @@
+package org.jcnc.snow.pkg.lifecycle;
+
+import org.jcnc.snow.pkg.tasks.Task;
+
+import java.util.EnumMap;
+import java.util.Map;
+
+/**
+ * 生命周期任务管理器。<br>
+ * 用于管理不同生命周期阶段与其对应 {@link Task}，并支持顺序执行所有已注册任务。
+ * <p>
+ * 可为每个 {@link LifecyclePhase} 注册对应的 {@link Task}，并在构建/部署流程中自动执行。
+ * </p>
+ *
+ * <pre>
+ * 示例用法：
+ * LifecycleManager manager = new LifecycleManager();
+ * manager.register(LifecyclePhase.INIT, new InitTask());
+ * manager.executeAll();
+ * </pre>
+ */
+public final class LifecycleManager {
+
+    /** 生命周期阶段与对应任务的映射关系 */
+    private final Map<LifecyclePhase, Task> tasks = new EnumMap<>(LifecyclePhase.class);
+
+    /**
+     * 为指定生命周期阶段注册任务。
+     * <p>若该阶段已有任务，则会被新任务覆盖。</p>
+     *
+     * @param phase 生命周期阶段，不能为空
+     * @param task  对应任务，不能为空
+     * @throws NullPointerException 若 phase 或 task 为 null
+     */
+    public void register(LifecyclePhase phase, Task task) {
+        if (phase == null) {
+            throw new NullPointerException("Lifecycle phase must not be null");
+        }
+        if (task == null) {
+            throw new NullPointerException("Task must not be null");
+        }
+        tasks.put(phase, task);
+    }
+
+    /**
+     * 按 {@link LifecyclePhase} 声明顺序依次执行所有已注册任务。
+     * <ul>
+     *   <li>未注册任务的阶段会被自动跳过</li>
+     *   <li>每个任务执行前会输出当前阶段名</li>
+     *   <li>执行中遇到异常将立即抛出并终止后续执行</li>
+     * </ul>
+     *
+     * @throws Exception 若某个任务执行时抛出异常，将直接抛出
+     */
+    public void executeAll() throws Exception {
+        for (LifecyclePhase phase : LifecyclePhase.values()) {
+            Task task = tasks.get(phase);
+            if (task != null) {
+                System.out.println(">>> Phase: " + phase);
+                task.run();
+            }
+        }
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/pkg/lifecycle/LifecyclePhase.java b/src/main/java/org/jcnc/snow/pkg/lifecycle/LifecyclePhase.java
new file mode 100644
index 0000000..39d9759
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/lifecycle/LifecyclePhase.java
@@ -0,0 +1,22 @@
+package org.jcnc.snow.pkg.lifecycle;
+
+/**
+ * 定义典型软件包生命周期的各个阶段枚举。
+ * <p>
+ * 用于区分构建、依赖、发布等不同阶段的任务调度与管理。
+ * </p>
+ */
+public enum LifecyclePhase {
+    /** 初始化阶段 */
+    INIT,
+    /** 解析依赖阶段 */
+    RESOLVE_DEPENDENCIES,
+    /** 编译阶段 */
+    COMPILE,
+    /** 打包阶段 */
+    PACKAGE,
+    /** 发布阶段 */
+    PUBLISH,
+    /** 清理阶段 */
+    CLEAN
+}
diff --git a/src/main/java/org/jcnc/snow/pkg/model/BuildConfiguration.java b/src/main/java/org/jcnc/snow/pkg/model/BuildConfiguration.java
new file mode 100644
index 0000000..de4b64c
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/model/BuildConfiguration.java
@@ -0,0 +1,64 @@
+package org.jcnc.snow.pkg.model;
+
+import java.util.Map;
+import java.util.HashMap;
+
+/**
+ * 构建配置对象，封装构建过程中的所有选项。
+ * <p>
+ * 支持模板变量（形如 <code>@{key}</code>）的值自动替换。
+ * </p>
+ */
+public final class BuildConfiguration {
+
+    /** 存储所有配置项 */
+    private final Map<String, String> options;
+
+    /**
+     * 私有构造函数，仅供工厂方法调用。
+     *
+     * @param options 配置项键值对
+     */
+    private BuildConfiguration(Map<String, String> options) {
+        this.options = options;
+    }
+
+    /**
+     * 基于原始配置项和属性集创建配置对象。
+     * <ul>
+     *   <li>会将所有值中的 <code>@{key}</code> 模板变量，替换为 props 中对应的值</li>
+     *   <li>属性未匹配到时保留原模板</li>
+     * </ul>
+     *
+     * @param flat  原始配置项，值中可包含模板变量
+     * @param props 变量替换用的属性集
+     * @return 处理后生成的配置对象
+     */
+    public static BuildConfiguration fromFlatMap(Map<String, String> flat, Map<String, String> props) {
+        Map<String, String> resolved = new HashMap<>();
+        for (Map.Entry<String, String> e : flat.entrySet()) {
+            String value = e.getValue();
+            for (Map.Entry<String, String> p : props.entrySet()) {
+                value = value.replace("@{" + p.getKey() + "}", p.getValue());
+            }
+            resolved.put(e.getKey(), value);
+        }
+        return new BuildConfiguration(resolved);
+    }
+
+    /**
+     * 获取指定配置项的值。
+     *
+     * @param key 配置项名称
+     * @param def 默认值（未找到时返回）
+     * @return 配置项值，若不存在则返回默认值
+     */
+    public String get(String key, String def) {
+        return options.getOrDefault(key, def);
+    }
+
+    @Override
+    public String toString() {
+        return options.toString();
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/pkg/model/Dependency.java b/src/main/java/org/jcnc/snow/pkg/model/Dependency.java
new file mode 100644
index 0000000..481682e
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/model/Dependency.java
@@ -0,0 +1,85 @@
+package org.jcnc.snow.pkg.model;
+
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * group:artifact:version 依赖坐标对象。
+ * <p>
+ * 支持占位符和属性映射进行动态变量替换，适用于 Snow 语言包管理和源码依赖场景。
+ * </p>
+ *
+ * <pre>
+ * 示例用法：
+ * Dependency dep = Dependency.fromString(
+ *     "core", "com.example:core:@{version}",
+ *     Map.of("version", "1.2.3")
+ * );
+ * </pre>
+ *
+ * @param id       依赖唯一标识
+ * @param group    组织/分组名
+ * @param artifact 构件名
+ * @param version  版本号
+ */
+public record Dependency(
+        String id,
+        String group,
+        String artifact,
+        String version
+) {
+
+    /** 匹配 group:artifact:version 格式的正则表达式。 */
+    private static final Pattern GAV = Pattern.compile("([^:]+):([^:]+):(.+)");
+
+    /**
+     * 根据字符串坐标和属性映射创建依赖对象。
+     * <p>
+     * 坐标中的占位符（如 <code>@{key}</code>）会用 props 中对应的值替换。
+     * </p>
+     *
+     * @param id         依赖唯一标识
+     * @param coordinate 坐标字符串，格式为 group:artifact:version，支持占位符
+     * @param props      占位符替换属性映射
+     * @return 解析后的 Dependency 实例
+     * @throws IllegalArgumentException 坐标格式非法时抛出
+     */
+    public static Dependency fromString(String id, String coordinate, Map<String, String> props) {
+        // 替换占位符
+        String resolved = coordinate;
+        for (Map.Entry<String, String> p : props.entrySet()) {
+            resolved = resolved.replace("@{" + p.getKey() + "}", p.getValue());
+        }
+
+        Matcher m = GAV.matcher(resolved);
+        if (!m.matches()) {
+            throw new IllegalArgumentException("Invalid dependency format: " + coordinate);
+        }
+        return new Dependency(id, m.group(1), m.group(2), m.group(3));
+    }
+
+    /**
+     * 生成依赖对应的源码文件路径。
+     * <p>
+     * 路径格式：groupId/artifactId/version/artifactId.snow
+     * 例如：com/example/core/1.2.3/core.snow
+     * </p>
+     *
+     * @return 仓库源码文件的相对路径
+     */
+    public String toPath() {
+        String groupPath = group.replace('.', '/');
+        return groupPath + "/" + artifact + "/" + version + "/" + artifact + ".snow";
+    }
+
+    /**
+     * 返回该依赖的 group:artifact:version 字符串表示。
+     *
+     * @return 坐标字符串
+     */
+    @Override
+    public String toString() {
+        return group + ":" + artifact + ":" + version;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/pkg/model/Project.java b/src/main/java/org/jcnc/snow/pkg/model/Project.java
new file mode 100644
index 0000000..efedc97
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/model/Project.java
@@ -0,0 +1,190 @@
+package org.jcnc.snow.pkg.model;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 表示一个软件包/模块的项目信息，包括元数据、属性、仓库、依赖和构建配置等。
+ * <p>
+ * 本类为不可变对象，仅提供 getter 方法，无 setter。<br>
+ * 支持通过 {@link #fromFlatMap(Map)} 静态工厂方法，从扁平 Map 快速创建实例。
+ * </p>
+ *
+ * <pre>
+ * Map&lt;String, String&gt; map = ...;
+ * Project project = Project.fromFlatMap(map);
+ * </pre>
+ */
+public final class Project {
+
+    /** 组织/分组名（如 com.example） */
+    private final String group;
+    /** 构件/模块名（如 app-core） */
+    private final String artifact;
+    /** 项目展示名称 */
+    private final String name;
+    /** 版本号（如 1.0.0） */
+    private final String version;
+    /** 项目描述 */
+    private final String description;
+    /** 许可证标识 */
+    private final String license;
+    /** 项目主页 URL */
+    private final String homepage;
+
+    /** 额外属性（不影响主字段，可用于模板/占位符） */
+    private final Map<String, String> properties;
+    /** 仓库列表（仓库 ID -> 仓库对象） */
+    private final Map<String, Repository> repositories;
+    /** 依赖列表 */
+    private final List<Dependency> dependencies;
+    /** 构建配置 */
+    private final BuildConfiguration build;
+
+    /**
+     * 构造函数（私有），请使用 {@link #fromFlatMap(Map)} 创建实例。
+     */
+    private Project(
+            String group,
+            String artifact,
+            String name,
+            String version,
+            String description,
+            String license,
+            String homepage,
+            Map<String, String> properties,
+            Map<String, Repository> repositories,
+            List<Dependency> dependencies,
+            BuildConfiguration build
+    ) {
+        this.group = group;
+        this.artifact = artifact;
+        this.name = name;
+        this.version = version;
+        this.description = description;
+        this.license = license;
+        this.homepage = homepage;
+        this.properties = properties;
+        this.repositories = repositories;
+        this.dependencies = dependencies;
+        this.build = build;
+    }
+
+    /**
+     * 通过扁平 Map 创建 Project 实例。key 格式约定如下：
+     * <ul>
+     *   <li>project.*      —— 项目元数据</li>
+     *   <li>properties.*   —— 额外属性</li>
+     *   <li>repositories.* —— 仓库</li>
+     *   <li>dependencies.* —— 依赖</li>
+     *   <li>build.*        —— 构建配置</li>
+     * </ul>
+     *
+     * @param map 扁平的配置 map
+     * @return Project 实例
+     */
+    public static Project fromFlatMap(Map<String, String> map) {
+        // 1. 基本元数据
+        String group = map.getOrDefault("project.group", "unknown");
+        String artifact = map.getOrDefault("project.artifact", "unknown");
+        String name = map.getOrDefault("project.name", artifact);
+        String version = map.getOrDefault("project.version", "0.0.1-SNAPSHOT");
+        String description = map.getOrDefault("project.description", "");
+        String license = map.getOrDefault("project.license", "");
+        String homepage = map.getOrDefault("project.homepage", "");
+
+        // 2. properties.*
+        Map<String, String> props = new LinkedHashMap<>();
+        map.forEach((k, v) -> {
+            if (k.startsWith("properties.")) {
+                props.put(k.substring("properties.".length()), v);
+            }
+        });
+
+        // 3. repositories.*
+        Map<String, Repository> repos = new LinkedHashMap<>();
+        map.forEach((k, v) -> {
+            if (k.startsWith("repositories.")) {
+                String id = k.substring("repositories.".length());
+                repos.put(id, new Repository(id, v));
+            }
+        });
+
+        // 4. dependencies.*
+        List<Dependency> deps = new ArrayList<>();
+        map.forEach((k, v) -> {
+            if (k.startsWith("dependencies.")) {
+                String id = k.substring("dependencies.".length());
+                deps.add(Dependency.fromString(id, v, props));
+            }
+        });
+
+        // 5. build.*
+        Map<String, String> buildMap = new LinkedHashMap<>();
+        map.forEach((k, v) -> {
+            if (k.startsWith("build.")) {
+                buildMap.put(k.substring("build.".length()), v);
+            }
+        });
+        BuildConfiguration buildCfg = BuildConfiguration.fromFlatMap(buildMap, props);
+
+        return new Project(group, artifact, name, version, description, license, homepage, props, repos, deps, buildCfg);
+    }
+
+    /** @return 组织/分组名 */
+    public String getGroup() {
+        return group;
+    }
+
+    /** @return 构件/模块名 */
+    public String getArtifact() {
+        return artifact;
+    }
+
+    /** @return 项目名称 */
+    public String getName() {
+        return name;
+    }
+
+    /** @return 版本号 */
+    public String getVersion() {
+        return version;
+    }
+
+    /** @return 项目描述 */
+    public String getDescription() {
+        return description;
+    }
+
+    /** @return 许可证标识 */
+    public String getLicense() {
+        return license;
+    }
+
+    /** @return 项目主页 URL */
+    public String getHomepage() {
+        return homepage;
+    }
+
+    /** @return 额外属性映射 */
+    public Map<String, String> getProperties() {
+        return properties;
+    }
+
+    /** @return 仓库映射 */
+    public Map<String, Repository> getRepositories() {
+        return repositories;
+    }
+
+    /** @return 依赖列表 */
+    public List<Dependency> getDependencies() {
+        return dependencies;
+    }
+
+    /** @return 构建配置 */
+    public BuildConfiguration getBuild() {
+        return build;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/pkg/model/Repository.java b/src/main/java/org/jcnc/snow/pkg/model/Repository.java
new file mode 100644
index 0000000..73d97b2
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/model/Repository.java
@@ -0,0 +1,18 @@
+package org.jcnc.snow.pkg.model;
+
+/**
+ * 表示一个远程仓库的基本信息，通常用于依赖解析和发布。
+ * <p>
+ * 每个仓库由唯一的 ID 和对应的 URL 标识。
+ * </p>
+ *
+ * <pre>
+ * 示例用法：
+ * Repository repo = new Repository("central", "https://");
+ * </pre>
+ *
+ * @param id  仓库唯一标识
+ * @param url 仓库地址（通常为 HTTP(S) 链接）
+ */
+public record Repository(String id, String url) {
+}
diff --git a/src/main/java/org/jcnc/snow/pkg/resolver/DependencyResolver.java b/src/main/java/org/jcnc/snow/pkg/resolver/DependencyResolver.java
new file mode 100644
index 0000000..7c9dcf8
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/resolver/DependencyResolver.java
@@ -0,0 +1,82 @@
+package org.jcnc.snow.pkg.resolver;
+
+import org.jcnc.snow.pkg.model.Dependency;
+import org.jcnc.snow.pkg.model.Project;
+import org.jcnc.snow.pkg.model.Repository;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.Optional;
+
+/**
+ * 负责解析并下载项目依赖的工具类。
+ * <p>
+ * 支持本地缓存，如果依赖已存在于本地缓存则直接使用，否则尝试从项目仓库下载依赖包。
+ * </p>
+ */
+public final class DependencyResolver {
+
+    /** 本地缓存目录 */
+    private final Path localCache;
+
+    /**
+     * 创建 DependencyResolver 实例。
+     *
+     * @param localCacheDir 用于缓存依赖的本地目录
+     */
+    public DependencyResolver(Path localCacheDir) {
+        this.localCache = localCacheDir;
+    }
+
+    /**
+     * 解析并下载指定项目的所有依赖。
+     * <p>
+     * 依赖优先从本地缓存读取，若未命中，则尝试从第一个配置的仓库下载。
+     * </p>
+     *
+     * @param project 要解析依赖的项目
+     * @throws IOException 下载或文件操作失败时抛出
+     */
+    public void resolve(Project project) throws IOException, URISyntaxException {
+        Files.createDirectories(localCache);
+        for (Dependency dep : project.getDependencies()) {
+            Path jarPath = localCache.resolve(dep.toPath());
+            if (Files.exists(jarPath)) {
+                System.out.println("[dependency] " + dep + " resolved from cache.");
+                continue;
+            }
+
+            // 从第一个仓库下载
+            Optional<Repository> repo = project.getRepositories().values().stream().findFirst();
+            if (repo.isEmpty()) {
+                throw new IOException("No repository configured for dependency " + dep);
+            }
+
+            String url = repo.get().url() + "/" + dep.toPath();
+            download(url, jarPath);
+        }
+    }
+
+    /**
+     * 从指定 URL 下载文件到本地目标路径。
+     *
+     * @param urlStr 远程文件 URL
+     * @param dest   本地目标路径
+     * @throws IOException 下载或保存文件时出错
+     */
+    private void download(String urlStr, Path dest) throws IOException, URISyntaxException {
+        System.out.println("[download] " + urlStr);
+        Files.createDirectories(dest.getParent());
+        URL url = new URI(urlStr).toURL();
+        try (InputStream in = url.openStream()) {
+            Files.copy(in, dest, StandardCopyOption.REPLACE_EXISTING);
+        }
+        System.out.println("[saved] " + dest);
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/pkg/tasks/CleanTask.java b/src/main/java/org/jcnc/snow/pkg/tasks/CleanTask.java
new file mode 100644
index 0000000..80700d6
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/tasks/CleanTask.java
@@ -0,0 +1,63 @@
+package org.jcnc.snow.pkg.tasks;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Comparator;
+
+/**
+ * 用于清理构建输出目录（如 {@code build} 和 {@code dist}）的任务实现类。
+ * <p>
+ * 实现 {@link Task} 接口，常用于自动化构建流程的清理阶段，负责递归删除指定的构建产物目录。
+ * </p>
+ * <p>
+ * 本类为无状态实现，线程安全。
+ * </p>
+ *
+ * <p><b>示例用法：</b></p>
+ * <pre>{@code
+ * Task clean = new CleanTask();
+ * clean.run();
+ * }</pre>
+ */
+public final class CleanTask implements Task {
+
+    /**
+     * 执行清理任务，递归删除当前目录下的 {@code build} 和 {@code dist} 目录及其所有内容。
+     * 如果目标目录不存在，则跳过不处理。
+     *
+     * @throws IOException 删除目录或文件过程中发生 IO 错误时抛出
+     */
+    @Override
+    public void run() throws IOException {
+        deleteDir(Path.of("build"));
+        deleteDir(Path.of("dist"));
+        System.out.println("[clean] done.");
+    }
+
+    /**
+     * 递归删除指定目录及其所有子文件和子目录。
+     * <p>
+     * 若目录不存在，则直接返回。
+     * </p>
+     * <p>
+     * 内部使用 try-with-resources 保证文件流自动关闭，避免资源泄漏。
+     * </p>
+     *
+     * @param dir 需要删除的目录路径
+     * @throws IOException 删除目录或文件过程中发生 IO 错误时抛出
+     */
+    private void deleteDir(Path dir) throws IOException {
+        if (Files.notExists(dir)) return;
+        try (var stream = Files.walk(dir)) {
+            stream.sorted(Comparator.reverseOrder()) // 先删子文件，后删父目录
+                    .forEach(p -> {
+                        try {
+                            Files.delete(p);
+                        } catch (IOException e) {
+                            throw new RuntimeException(e);
+                        }
+                    });
+        }
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/pkg/tasks/CompileTask.java b/src/main/java/org/jcnc/snow/pkg/tasks/CompileTask.java
new file mode 100644
index 0000000..4d8e9d1
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/tasks/CompileTask.java
@@ -0,0 +1,270 @@
+package org.jcnc.snow.pkg.tasks;
+
+import org.jcnc.snow.cli.commands.CompileCommand;
+import org.jcnc.snow.compiler.backend.utils.OpHelper;
+import org.jcnc.snow.compiler.backend.alloc.RegisterAllocator;
+import org.jcnc.snow.compiler.backend.builder.VMCodeGenerator;
+import org.jcnc.snow.compiler.backend.builder.VMProgramBuilder;
+import org.jcnc.snow.compiler.backend.core.InstructionGenerator;
+import org.jcnc.snow.compiler.backend.generator.InstructionGeneratorProvider;
+import org.jcnc.snow.compiler.ir.builder.IRProgramBuilder;
+import org.jcnc.snow.compiler.ir.core.IRFunction;
+import org.jcnc.snow.compiler.ir.core.IRInstruction;
+import org.jcnc.snow.compiler.ir.core.IRProgram;
+import org.jcnc.snow.compiler.ir.value.IRVirtualRegister;
+import org.jcnc.snow.compiler.lexer.core.LexerEngine;
+import org.jcnc.snow.compiler.parser.ast.base.Node;
+import org.jcnc.snow.compiler.parser.context.ParserContext;
+import org.jcnc.snow.compiler.parser.core.ParserEngine;
+import org.jcnc.snow.compiler.parser.function.ASTPrinter;
+import org.jcnc.snow.compiler.semantic.core.SemanticAnalyzerRunner;
+import org.jcnc.snow.pkg.model.Project;
+import org.jcnc.snow.vm.VMLauncher;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+
+/**
+ * CLI 任务：编译 .snow 源文件为 VM 字节码（.water 文件）。
+ * <p>
+ * 支持单文件、多文件和目录递归编译，并可在编译后立即运行虚拟机。<br>
+ * 命令行参数支持 run、-o、-d 及直接指定源文件。
+ * </p>
+ *
+ * <pre>
+ * 用法示例：
+ * $ snow compile [run] [-o &lt;name&gt;] [-d &lt;srcDir&gt;] [file1.snow file2.snow ...]
+ * </pre>
+ */
+public final class CompileTask implements Task {
+    /** 项目信息 */
+    private final Project project;
+    /** 原始命令行参数 */
+    private final String[] args;
+
+    /**
+     * 创建一个编译任务。
+     *
+     * @param project  项目信息对象
+     * @param args     命令行参数数组
+     */
+    public CompileTask(Project project, String[] args) {
+        this.project = project;
+        this.args = args;
+    }
+
+    /**
+     * 创建一个不带参数的编译任务。
+     *
+     * @param project 项目信息对象
+     */
+    public CompileTask(Project project) {
+        this(project, new String[0]);
+    }
+
+    /**
+     * 执行编译任务。该方法会解析参数并调用 {@link #execute(String[])} 进行实际编译流程。
+     *
+     * @throws Exception 执行过程中出现任意异常时抛出
+     */
+    @Override
+    public void run() throws Exception {
+        execute(this.args);
+    }
+
+    /**
+     * 编译 .snow 源文件为 VM 字节码，并可选择立即运行。
+     * <ul>
+     *   <li>支持参数 run（编译后运行）、-o（输出文件名）、-d（递归目录）、直接指定多个源文件。</li>
+     *   <li>输出源代码、AST、IR、最终 VM code，并写出 .water 文件。</li>
+     * </ul>
+     *
+     * @param args 命令行参数数组
+     * @return 0 表示成功，非 0 表示失败
+     * @throws Exception 编译或写入过程中出现异常时抛出
+     */
+    public int execute(String[] args) throws Exception {
+        // ---------------- 解析命令行参数 ----------------
+        boolean runAfterCompile = false;
+        String outputName = null;
+        Path dir = null;
+        List<Path> sources = new ArrayList<>();
+
+        for (int i = 0; i < args.length; i++) {
+            String arg = args[i];
+            switch (arg) {
+                case "run" -> runAfterCompile = true;
+                case "-o" -> {
+                    if (i + 1 < args.length) outputName = args[++i];
+                    else {
+                        System.err.println("Missing argument for -o");
+                        new CompileCommand().printUsage();
+                        return 1;
+                    }
+                }
+                case "-d" -> {
+                    if (i + 1 < args.length) dir = Path.of(args[++i]);
+                    else {
+                        System.err.println("Missing argument for -d");
+                        new CompileCommand().printUsage();
+                        return 1;
+                    }
+                }
+                default -> {
+                    if (arg.endsWith(".snow")) {
+                        sources.add(Path.of(arg));
+                    } else {
+                        System.err.println("Unknown option or file: " + arg);
+                        new CompileCommand().printUsage();
+                        return 1;
+                    }
+                }
+            }
+        }
+
+        // --------- 如果指定了目录则递归收集所有 *.snow ---------
+        if (dir != null) {
+            if (!Files.isDirectory(dir)) {
+                System.err.println("Not a directory: " + dir);
+                return 1;
+            }
+            try (var stream = Files.walk(dir)) {
+                stream.filter(p -> p.toString().endsWith(".snow"))
+                        .sorted()                       // 确保稳定顺序
+                        .forEach(sources::add);
+            }
+        }
+
+        if (sources.isEmpty()) {
+            System.err.println("No .snow source files found.");
+            return 1;
+        }
+
+        // 多文件但未指定 -o 且非目录编译 —— 提示必须指定输出名
+        if (sources.size() > 1 && outputName == null && dir == null) {
+            System.err.println("Please specify output name using -o <name>");
+            return 1;
+        }
+
+        // ---------------- 1. 词法/语法分析，并打印源代码 ----------------
+        List<Node> allAst = new ArrayList<>();
+
+        System.out.println("## 编译器输出");
+        System.out.println("### Snow 源代码");
+
+        for (Path p : sources) {
+            if (!Files.exists(p)) {
+                System.err.println("File not found: " + p);
+                return 1;
+            }
+
+            String code = Files.readString(p, StandardCharsets.UTF_8);
+
+            // 打印源码
+            System.out.println("#### " + p.getFileName());
+            System.out.println(code);
+
+            // 词法、语法分析
+            LexerEngine lexer = new LexerEngine(code, p.toString());
+            ParserContext ctx = new ParserContext(lexer.getAllTokens(), p.toString());
+            allAst.addAll(new ParserEngine(ctx).parse());
+        }
+
+        // ---------------- 2. 语义分析 ----------------
+        SemanticAnalyzerRunner.runSemanticAnalysis(allAst, false);
+
+        // ---------------- 3. AST → IR，并将 main 函数移动至首位 ----------------
+        IRProgram program = new IRProgramBuilder().buildProgram(allAst);
+        program = reorderForEntry(program);
+
+        // 打印 AST 和 IR
+        System.out.println("### AST");
+        ASTPrinter.printJson(allAst);
+
+        System.out.println("### IR");
+        System.out.println(program);
+
+        // ---------------- 4. IR → VM 指令 ----------------
+        VMProgramBuilder builder = new VMProgramBuilder();
+        List<InstructionGenerator<? extends IRInstruction>> generators =
+                InstructionGeneratorProvider.defaultGenerators();
+
+        for (IRFunction fn : program.functions()) {
+            Map<IRVirtualRegister, Integer> slotMap =
+                    new RegisterAllocator().allocate(fn);
+            new VMCodeGenerator(slotMap, builder, generators).generate(fn);
+        }
+        List<String> finalCode = builder.build();
+
+        System.out.println("### VM code");
+        for (int i = 0; i < finalCode.size(); i++) {
+            String[] parts = finalCode.get(i).split(" ");
+            String name = OpHelper.opcodeName(parts[0]);
+            parts = Arrays.copyOfRange(parts, 1, parts.length);
+            System.out.printf("%04d: %-10s %s\n", i, name, String.join(" ", parts));
+        }
+
+        // ---------------- 5. 写出 .water 文件 ----------------
+        Path outputFile = deriveOutputPath(sources, outputName, dir);
+        Files.write(outputFile, finalCode, StandardCharsets.UTF_8);
+        System.out.println("Written to " + outputFile.toAbsolutePath());
+
+        // ---------------- 6. 可选：立即运行 VM ----------------
+        if (runAfterCompile) {
+            System.out.println("\n=== Launching VM ===");
+            VMLauncher.main(new String[]{outputFile.toString()});
+        }
+
+        return 0;
+    }
+
+    /**
+     * 推断 .water 输出文件名。
+     * <ul>
+     *   <li>如果指定 -o，直接使用该名称。</li>
+     *   <li>目录编译时，取目录名。</li>
+     *   <li>单文件编译时，取文件名去掉 .snow 后缀。</li>
+     *   <li>否则默认 "program"。</li>
+     * </ul>
+     *
+     * @param sources   源文件路径列表
+     * @param outName   输出文件名（如有指定，否则为 null）
+     * @param dir       源码目录（如有指定，否则为 null）
+     * @return 推断出的输出文件路径（.water 文件）
+     */
+    private static Path deriveOutputPath(List<Path> sources, String outName, Path dir) {
+        String base;
+        if (outName != null) {
+            base = outName;
+        } else if (dir != null) {
+            base = dir.getFileName().toString();
+        } else if (sources.size() == 1) {
+            base = sources.getFirst().getFileName().toString()
+                    .replaceFirst("\\.snow$", "");
+        } else {
+            base = "program";
+        }
+        return Path.of(base + ".water");
+    }
+
+    /**
+     * 将 main 函数调整至函数列表首位，确保程序入口为 PC=0。
+     *
+     * @param in 原始 IRProgram
+     * @return 调整入口后的 IRProgram
+     */
+    private static IRProgram reorderForEntry(IRProgram in) {
+        List<IRFunction> ordered = new ArrayList<>(in.functions());
+        for (int i = 0; i < ordered.size(); i++) {
+            if ("main".equals(ordered.get(i).name())) {
+                Collections.swap(ordered, 0, i);
+                break;
+            }
+        }
+        IRProgram out = new IRProgram();
+        ordered.forEach(out::add);
+        return out;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/pkg/tasks/GenerateTask.java b/src/main/java/org/jcnc/snow/pkg/tasks/GenerateTask.java
new file mode 100644
index 0000000..83b9253
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/tasks/GenerateTask.java
@@ -0,0 +1,95 @@
+package org.jcnc.snow.pkg.tasks;
+
+import org.jcnc.snow.pkg.model.Project;
+import org.jcnc.snow.pkg.utils.SnowExample;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 项目脚手架生成任务。<br>
+ * 根据 {@link Project} 元数据自动创建标准项目目录结构，并生成示例入口文件
+ * <code>main.snow</code>。
+ *
+ * <p>
+ * 生成内容包括：
+ * <ul>
+ *   <li><code>src/</code>                       —— 源码根目录</li>
+ *   <li><code>src/{group package}/</code> —— 按 <code>project.group</code> 创建的包路径
+ *       （如 <code>com.example</code> → <code>src/com/example/</code>）</li>
+ *   <li><code>test/</code>                     —— 测试源码目录</li>
+ *   <li><code>build/</code>                     —— 编译输出目录</li>
+ *   <li><code>dist/</code>                      —— 打包输出目录</li>
+ *   <li><code>src/{group package}/main.snow</code> —— 示例入口文件</li>
+ * </ul>
+ * 如目录或入口文件已存在，则自动跳过，不会覆盖。
+ * </p>
+ */
+public final class GenerateTask implements Task {
+
+    /** 项目信息元数据 */
+    private final Project project;
+
+    /**
+     * 创建项目生成任务。
+     *
+     * @param project 项目信息元数据对象
+     */
+    public GenerateTask(Project project) {
+        this.project = project;
+    }
+
+    /**
+     * 执行脚手架生成流程，创建标准目录和入口示例文件。
+     * <ul>
+     *   <li>若相关目录不存在则创建</li>
+     *   <li>若设置了 <code>project.group</code>，则在 <code>src/</code> 下新建对应包路径</li>
+     *   <li>示例入口文件 <code>main.snow</code> 写入包路径目录</li>
+     *   <li>生成过程输出进度信息</li>
+     * </ul>
+     *
+     * @throws IOException 创建目录或写入文件时发生 IO 错误时抛出
+     */
+    @Override
+    public void run() throws IOException {
+        Path root = Paths.get(".").toAbsolutePath();
+
+        /* ---------- 1. 构造待创建目录列表 ---------- */
+        List<Path> dirs = new ArrayList<>(List.of(
+                root.resolve("src"),
+                root.resolve("test"),
+                root.resolve("build"),
+                root.resolve("dist")
+        ));
+
+        /* ---------- 2. 处理 group：追加包目录 ---------- */
+        String group = project != null ? project.getGroup() : null;
+        Path srcDir = root.resolve("src");
+        Path packageDir = srcDir;  // 默认直接在 src 下
+        if (group != null && !group.isBlank()) {
+            packageDir = srcDir.resolve(group.replace('.', '/'));
+            dirs.add(packageDir);
+        }
+
+        /* ---------- 3. 创建目录 ---------- */
+        for (Path dir : dirs) {
+            if (Files.notExists(dir)) {
+                Files.createDirectories(dir);
+                System.out.println("[generate] created directory " + root.relativize(dir));
+            }
+        }
+
+        /* ---------- 4. 写入示例入口文件 main.snow ---------- */
+        Path mainSnow = packageDir.resolve("main.snow");
+        if (Files.notExists(mainSnow)) {
+            Files.writeString(mainSnow, SnowExample.getMainModule());
+            System.out.println("[generate] created " + root.relativize(mainSnow));
+        }
+
+        System.out.println("[generate] project scaffold is ready.");
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/pkg/tasks/PackageTask.java b/src/main/java/org/jcnc/snow/pkg/tasks/PackageTask.java
new file mode 100644
index 0000000..a04dcf0
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/tasks/PackageTask.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.pkg.tasks;
+
+import org.jcnc.snow.pkg.model.Project;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+/**
+ * 项目打包任务，将编译输出目录（如 <code>build/classes</code>）打包为 .ice 文件。
+ * <p>
+ * 实现 {@link Task} 接口，通常用于构建流程的打包阶段。<br>
+ * 只会打包 build/classes 目录下所有文件，不含其他目录。
+ * </p>
+ * <p>
+ * 输出文件位于 dist 目录，命名为 artifact-version.ice。
+ * </p>
+ */
+public final class PackageTask implements Task {
+
+    /** 目标项目元数据 */
+    private final Project project;
+
+    /**
+     * 创建打包任务。
+     *
+     * @param project 目标项目元数据
+     */
+    public PackageTask(Project project) {
+        this.project = project;
+    }
+
+    /**
+     * 执行打包任务，将 build/classes 目录下所有文件压缩为 dist/artifact-version.ice。
+     * <ul>
+     *   <li>若输出目录 dist 不存在会自动创建</li>
+     *   <li>只打包 build/classes 下所有普通文件（保持相对目录结构）</li>
+     *   <li>如无 build/classes 则不会生成包</li>
+     * </ul>
+     *
+     * @throws Exception 打包过程中发生 IO 或其他异常时抛出
+     */
+    @Override
+    public void run() throws Exception {
+        String artifact = project.getArtifact();
+        String version = project.getVersion();
+        String fileName = artifact + "-" + version + ".ice";
+        Path distDir = Path.of("dist");
+        Files.createDirectories(distDir);
+        Path packageFile = distDir.resolve(fileName);
+
+        try (ZipOutputStream zos = new ZipOutputStream(Files.newOutputStream(packageFile))) {
+            // 仅将 build/classes 目录打包
+            Path classesDir = Path.of("build/classes");
+            if (Files.exists(classesDir)) {
+                // 遍历所有文件并写入 zip
+                try (Stream<Path> stream = Files.walk(classesDir)) {
+                    stream.filter(Files::isRegularFile)
+                            .forEach(p -> {
+                                try {
+                                    // 以 classesDir 为根的相对路径存入 zip
+                                    zos.putNextEntry(new ZipEntry(classesDir.relativize(p).toString()));
+                                    Files.copy(p, zos);
+                                    zos.closeEntry();
+                                } catch (Exception e) {
+                                    throw new RuntimeException(e);
+                                }
+                            });
+                }
+            }
+        }
+        System.out.println("[package] created " + packageFile);
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/pkg/tasks/PublishTask.java b/src/main/java/org/jcnc/snow/pkg/tasks/PublishTask.java
new file mode 100644
index 0000000..310b8fa
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/tasks/PublishTask.java
@@ -0,0 +1,36 @@
+package org.jcnc.snow.pkg.tasks;
+
+import org.jcnc.snow.pkg.model.Project;
+
+/**
+ * 发布项目构件到远程仓库的任务实现。
+ * <p>
+ * 实现 {@link Task} 接口，通常用于构建流程中的发布阶段。
+ * 当前仅输出发布提示，尚未实现实际上传功能。
+ * </p>
+ */
+public final class PublishTask implements Task {
+
+    /** 目标项目元数据 */
+    private final Project project;
+
+    /**
+     * 创建发布任务。
+     *
+     * @param project 目标项目元数据
+     */
+    public PublishTask(Project project) {
+        this.project = project;
+    }
+
+    /**
+     * 执行发布任务。目前仅打印发布提示信息，未实现实际上传逻辑。
+     *
+     * @throws Exception 预留，未来实现上传逻辑时可能抛出异常
+     */
+    @Override
+    public void run() throws Exception {
+        // TODO: 实现上传到仓库（如 HTTP PUT/POST）
+        System.out.println("[publish] uploading artifact " + project.getArtifact() + "-" + project.getVersion());
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/pkg/tasks/RunTask.java b/src/main/java/org/jcnc/snow/pkg/tasks/RunTask.java
new file mode 100644
index 0000000..ce83966
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/tasks/RunTask.java
@@ -0,0 +1,44 @@
+package org.jcnc.snow.pkg.tasks;
+
+import org.jcnc.snow.vm.VMLauncher;
+
+/**
+ * 任务：执行已编译的 VM 字节码文件（.water）。
+ * <p>
+ * 作为 CLI、IDE 插件或其他宿主环境启动虚拟机的统一入口，<br>
+ * 通过调用 {@link VMLauncher#main(String[])} 启动 VM 并执行指定程序。
+ * </p>
+ */
+public final class RunTask implements Task {
+
+    /**
+     * 传递给虚拟机的完整参数列表（第一个应为 .water 文件路径）
+     */
+    private final String[] args;
+
+    /**
+     * 创建运行任务。
+     *
+     * @param args VM 参数数组（第一个为 .water 程序路径，其后为可选参数）
+     */
+    public RunTask(String... args) {
+        this.args = args;
+    }
+
+    /**
+     * 执行运行任务。内部委托 {@link VMLauncher#main(String[])} 启动 VM。
+     * <ul>
+     *   <li>如果参数为空则抛出 {@link IllegalArgumentException}</li>
+     *   <li>异常由虚拟机本身抛出，直接透出</li>
+     * </ul>
+     *
+     * @throws Exception 虚拟机启动或运行期间抛出的异常
+     */
+    @Override
+    public void run() throws Exception {
+        if (args == null || args.length == 0) {
+            throw new IllegalArgumentException("VM run requires at least the program file path.");
+        }
+        VMLauncher.main(args);
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/pkg/tasks/Task.java b/src/main/java/org/jcnc/snow/pkg/tasks/Task.java
new file mode 100644
index 0000000..071fdbc
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/tasks/Task.java
@@ -0,0 +1,17 @@
+package org.jcnc.snow.pkg.tasks;
+
+/**
+ * 构建任务的通用接口，所有具体任务（如编译、打包、清理等）都应实现该接口。
+ * <p>
+ * 用于统一不同阶段任务的生命周期与执行行为。
+ * </p>
+ */
+public interface Task {
+
+    /**
+     * 执行具体任务的入口方法。
+     *
+     * @throws Exception 任务执行过程中出现的任意异常
+     */
+    void run() throws Exception;
+}
diff --git a/src/main/java/org/jcnc/snow/pkg/utils/SnowExample.java b/src/main/java/org/jcnc/snow/pkg/utils/SnowExample.java
new file mode 100644
index 0000000..ffd18d1
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/pkg/utils/SnowExample.java
@@ -0,0 +1,58 @@
+package org.jcnc.snow.pkg.utils;
+
+/**
+ * 示例模块模板工具类，提供 main.snow 的标准示例代码字符串。
+ * <p>
+ * 用于项目脚手架生成或帮助用户快速上手 .snow 语言。
+ * </p>
+ */
+public final class SnowExample {
+
+    /**
+     * 工具类构造方法，禁止实例化。
+     */
+    private SnowExample() {
+        // 工具类不允许实例化
+    }
+
+    /**
+     * 获取 main.snow 示例模块的内容字符串。
+     *
+     * @return main.snow 示例模块的完整代码
+     */
+    public static String getMainModule() {
+        return """
+                module: Math
+                    function: main
+                        parameter:
+                        return_type: int
+                        body:
+                            Math.factorial(6)
+                            return 0
+                        end body
+                    end function
+                
+                    function: factorial
+                        parameter:
+                            declare n: int
+                        return_type: int
+                        body:
+                            declare num1: int = 1
+                            loop:
+                                initializer:
+                                    declare counter:int = 1
+                                condition:
+                                    counter <= n
+                                update:
+                                    counter = counter + 1
+                                body:
+                                    num1 = num1 * counter
+                                end body
+                            end loop
+                            return num1
+                        end body
+                    end function
+                end module
+                """;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/VMLauncher.java b/src/main/java/org/jcnc/snow/vm/VMLauncher.java
index bbcfca8..345d9d1 100644
--- a/src/main/java/org/jcnc/snow/vm/VMLauncher.java
+++ b/src/main/java/org/jcnc/snow/vm/VMLauncher.java
@@ -44,6 +44,6 @@ public class VMLauncher {
      */
     public static void main(String[] args) {
         // Call the method that initializes and runs the VM in DEBUG mode
-        initializeAndRunVM(args, VMMode.DEBUG);
+        initializeAndRunVM(args, VMMode.RUN);
     }
 }
diff --git a/src/main/java/org/jcnc/snow/vm/commands/function/CallCommand.java b/src/main/java/org/jcnc/snow/vm/commands/flow/control/CallCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/function/CallCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/flow/control/CallCommand.java
index a384570..befbfea 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/function/CallCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/flow/control/CallCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.function;
+package org.jcnc.snow.vm.commands.flow.control;
 
 import org.jcnc.snow.vm.engine.VMMode;
 import org.jcnc.snow.vm.interfaces.Command;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/control/all/JumpCommand.java b/src/main/java/org/jcnc/snow/vm/commands/flow/control/JumpCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/control/all/JumpCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/flow/control/JumpCommand.java
index 63418da..7f53890 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/control/all/JumpCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/flow/control/JumpCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.control.all;
+package org.jcnc.snow.vm.commands.flow.control;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.utils.LoggingUtils;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/function/RetCommand.java b/src/main/java/org/jcnc/snow/vm/commands/flow/control/RetCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/function/RetCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/flow/control/RetCommand.java
index af37032..f2190fd 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/function/RetCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/flow/control/RetCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.function;
+package org.jcnc.snow.vm.commands.flow.control;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.*;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/memory/all/MovCommand.java b/src/main/java/org/jcnc/snow/vm/commands/register/control/MovCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/memory/all/MovCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/register/control/MovCommand.java
index dd0b11b..2c1e62b 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/memory/all/MovCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/register/control/MovCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.memory.all;
+package org.jcnc.snow.vm.commands.register.control;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/stack/all/DupCommand.java b/src/main/java/org/jcnc/snow/vm/commands/stack/control/DupCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/stack/all/DupCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/stack/control/DupCommand.java
index 8d0d1f8..4a45c8a 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/stack/all/DupCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/stack/control/DupCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.stack.all;
+package org.jcnc.snow.vm.commands.stack.control;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/stack/all/PopCommand.java b/src/main/java/org/jcnc/snow/vm/commands/stack/control/PopCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/stack/all/PopCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/stack/control/PopCommand.java
index fe00f9d..fbc89e7 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/stack/all/PopCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/stack/control/PopCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.stack.all;
+package org.jcnc.snow.vm.commands.stack.control;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/stack/all/SwapCommand.java b/src/main/java/org/jcnc/snow/vm/commands/stack/control/SwapCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/stack/all/SwapCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/stack/control/SwapCommand.java
index 1f27318..5d89bea 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/stack/all/SwapCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/stack/control/SwapCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.stack.all;
+package org.jcnc.snow.vm.commands.stack.control;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/vm/HaltCommand.java b/src/main/java/org/jcnc/snow/vm/commands/system/control/HaltCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/vm/HaltCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/system/control/HaltCommand.java
index 19e4d5d..06a5da4 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/vm/HaltCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/system/control/HaltCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.vm;
+package org.jcnc.snow.vm.commands.system.control;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.utils.LoggingUtils;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BAddCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BAddCommand.java
similarity index 96%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BAddCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BAddCommand.java
index b05f809..7da2644 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BAddCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BAddCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.byte8;
+package org.jcnc.snow.vm.commands.type.control.byte8;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
@@ -50,7 +50,7 @@ public class BAddCommand implements Command {
         byte a = (byte) operandStack.pop();
 
         // Perform the addition and push the result back onto the stack
-        operandStack.push(a + b);
+        operandStack.push((byte)(a + b));
 
         // Return the updated program counter (next instruction)
         return currentPC + 1;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BAndCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BAndCommand.java
new file mode 100644
index 0000000..8eb94c9
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BAndCommand.java
@@ -0,0 +1,56 @@
+package org.jcnc.snow.vm.commands.type.control.byte8;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+
+/**
+ * The BAndCommand class implements the {@link Command} interface and represents the byte8 bitwise AND (`&`) operation command.
+ * This class performs a byte8 bitwise AND operation in the virtual machine by popping the top two values from the stack,
+ * computing their byte8 bitwise AND operation, and then pushing the result back onto the stack. It is a basic operation command within the virtual machine.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two operands from the virtual machine stack.</li>
+ *     <li>Performs the byte8 bitwise AND (`&`) operation.</li>
+ *     <li>Pushes the result back onto the virtual machine stack.</li>
+ * </ul>
+ */
+public class BAndCommand implements Command {
+    /**
+     * Default constructor for creating an instance of {@code BAndCommand}.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public BAndCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for pushing and popping values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables.
+     * @param callStack          The virtual machine's call stack, used for managing method calls and returns.
+     * @return The updated program counter-value, typically `currentPC + 1` unless a control flow instruction is executed.
+     * @throws IllegalStateException if there are not enough operands on the stack to perform the operation.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Ensure the stack has at least two operands
+        if (operandStack.size() < 2) {
+            throw new IllegalStateException("Not enough operands on the stack for BAND operation.");
+        }
+
+        // Pop the top two operands from the stack
+        final byte b = (byte) operandStack.pop();
+        final byte a = (byte) operandStack.pop();
+
+        // Perform the byte8 bitwise AND operation and push the result back onto the stack
+        operandStack.push((byte)(a & b));
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCECommand.java
new file mode 100644
index 0000000..d60839f
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.byte8;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The BCECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if they are equal, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two byte8 from the virtual machine stack.</li>
+ *     <li>If the two byte8 are equal, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class BCECommand implements Command {
+    /**
+     * Default constructor for creating an instance of BCECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public BCECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        byte b = (byte) operandStack.pop();
+        byte a = (byte) operandStack.pop();
+
+        // If the operands are equal, jump to the target command
+        if (a == b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCGCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCGCommand.java
new file mode 100644
index 0000000..bf12f76
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCGCommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.byte8;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The BCGCommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is greater than the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two byte8 from the virtual machine stack.</li>
+ *     <li>If the first byte8 is greater than the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class BCGCommand implements Command {
+    /**
+     * Default constructor for creating an instance of BCGCommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public BCGCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        byte b = (byte) operandStack.pop();
+        byte a = (byte) operandStack.pop();
+
+        // If the first operand is greater than the second, jump to the target command
+        if (a > b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCGECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCGECommand.java
new file mode 100644
index 0000000..6173eae
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCGECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.byte8;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The BCGECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is greater than or equal to the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two byte8 from the virtual machine stack.</li>
+ *     <li>If the first byte8 is greater than or equal to the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class BCGECommand implements Command {
+    /**
+     * Default constructor for creating an instance of BCGECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public BCGECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        byte b = (byte) operandStack.pop();
+        byte a = (byte) operandStack.pop();
+
+        // If the first operand is greater than or equal to the second, jump to the target command
+        if (a >= b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCLCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCLCommand.java
new file mode 100644
index 0000000..a7cf1cb
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCLCommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.byte8;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The BCLCommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is less than the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two byte8 from the virtual machine stack.</li>
+ *     <li>If the first byte8 is less than the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class BCLCommand implements Command {
+    /**
+     * Default constructor for creating an instance of BCLCommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public BCLCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        byte b = (byte) operandStack.pop();
+        byte a = (byte) operandStack.pop();
+
+        // If the first operand is less than the second, jump to the target command
+        if (a < b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCLECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCLECommand.java
new file mode 100644
index 0000000..e4a3aa5
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCLECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.byte8;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The BCLECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is less than or equal to the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two byte8 from the virtual machine stack.</li>
+ *     <li>If the first byte8 is less than or equal to the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class BCLECommand implements Command {
+    /**
+     * Default constructor for creating an instance of BCLECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public BCLECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        byte b = (byte) operandStack.pop();
+        byte a = (byte) operandStack.pop();
+
+        // If the first operand is less than or equal to the second, jump to the target command
+        if (a <= b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCNECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCNECommand.java
new file mode 100644
index 0000000..497b6c4
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BCNECommand.java
@@ -0,0 +1,77 @@
+package org.jcnc.snow.vm.commands.type.control.byte8;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The BCNECommand class implements the {@link Command} interface and represents a conditional jump command
+ * in the virtual machine that triggers if two values are not equal.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two byte8 from the virtual machine stack.</li>
+ *     <li>If the two byte8 are not equal, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class BCNECommand implements Command {
+    /**
+     * Default constructor for creating an instance of BCNECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public BCNECommand() {
+
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        byte b = (byte) operandStack.pop();
+        byte a = (byte) operandStack.pop();
+
+        // If the operands are not equal, jump to the target command
+        if (a != b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BDivCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BDivCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BDivCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BDivCommand.java
index ad24912..b71abb7 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BDivCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BDivCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.byte8;
+package org.jcnc.snow.vm.commands.type.control.byte8;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
@@ -56,7 +56,7 @@ public class BDivCommand implements Command {
         }
 
         // Perform the division and push the result back onto the stack
-        operandStack.push(a / b);
+        operandStack.push((byte)(a / b));
 
         // Return the updated program counter (next instruction)
         return currentPC + 1;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BIncCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BIncCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BIncCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BIncCommand.java
index 8d2dd72..c7fa3e4 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BIncCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BIncCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.byte8;
+package org.jcnc.snow.vm.commands.type.control.byte8;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/memory/byte8/BLoadCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BLoadCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/memory/byte8/BLoadCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BLoadCommand.java
index c42e645..bf93d12 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/memory/byte8/BLoadCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BLoadCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.memory.byte8;
+package org.jcnc.snow.vm.commands.type.control.byte8;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BModCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BModCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BModCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BModCommand.java
index 88b12bd..9a4747b 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BModCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BModCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.byte8;
+package org.jcnc.snow.vm.commands.type.control.byte8;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
@@ -50,7 +50,7 @@ public class BModCommand implements Command {
         byte a = (byte) operandStack.pop();
 
         // Perform the modulus operation and push the result back onto the stack
-        operandStack.push(a % b);
+        operandStack.push((byte)(a % b));
 
         // Return the updated program counter (next instruction)
         return currentPC + 1;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BMulCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BMulCommand.java
similarity index 96%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BMulCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BMulCommand.java
index e5de63a..8f0bc7d 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BMulCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BMulCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.byte8;
+package org.jcnc.snow.vm.commands.type.control.byte8;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
@@ -50,7 +50,7 @@ public class BMulCommand implements Command {
         byte a = (byte) operandStack.pop();
 
         // Perform the multiplication and push the result back onto the stack
-        operandStack.push(a * b);
+        operandStack.push((byte)(a * b));
 
         // Return the updated program counter (next instruction)
         return currentPC + 1;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BNegCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BNegCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BNegCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BNegCommand.java
index d6b67e2..5f41f27 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BNegCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BNegCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.byte8;
+package org.jcnc.snow.vm.commands.type.control.byte8;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BOrCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BOrCommand.java
new file mode 100644
index 0000000..e29aaae
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BOrCommand.java
@@ -0,0 +1,56 @@
+package org.jcnc.snow.vm.commands.type.control.byte8;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+
+/**
+ * The {@code BOrCommand} class implements the {@link Command} interface and represents the byte8 bitwise OR (`|`) operation command.
+ * This class performs a byte8 bitwise OR operation in the virtual machine by popping the top two values from the stack,
+ * computing their OR, and then pushing the result back onto the stack. It is a basic operation command within the virtual machine.
+ *
+ * <p><b>Operation details:</b></p>
+ * <ul>
+ *     <li>Pops two operands from the virtual machine stack.</li>
+ *     <li>Performs the byte8 bitwise OR (`|`) operation.</li>
+ *     <li>Pushes the result back onto the virtual machine stack.</li>
+ * </ul>
+ */
+public class BOrCommand implements Command {
+    /**
+     * Default constructor for creating an instance of {@code BOrCommand}.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public BOrCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing stack operations.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of method invocations.
+     * @return The updated program counter-value, typically {@code currentPC + 1}, unless a control flow instruction is executed.
+     * @throws IllegalStateException if there are not enough operands on the stack to perform the operation.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Ensure the stack has at least two operands
+        if (operandStack.size() < 2) {
+            throw new IllegalStateException("Not enough operands on the stack for BOR operation.");
+        }
+
+        // Pop the top two operands from the stack
+        final byte b = (byte) operandStack.pop();
+        final byte a = (byte) operandStack.pop();
+
+        // Perform the byte8 bitwise OR operation and push the result back onto the stack
+        operandStack.push((byte)(a | b));
+
+        return currentPC + 1;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/vm/commands/stack/byte8/BPushCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BPushCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/stack/byte8/BPushCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BPushCommand.java
index 6953ff8..c2740fe 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/stack/byte8/BPushCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BPushCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.stack.byte8;
+package org.jcnc.snow.vm.commands.type.control.byte8;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/memory/byte8/BStoreCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BStoreCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/memory/byte8/BStoreCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BStoreCommand.java
index 47211d1..b0cabfb 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/memory/byte8/BStoreCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BStoreCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.memory.byte8;
+package org.jcnc.snow.vm.commands.type.control.byte8;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BSubCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BSubCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BSubCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BSubCommand.java
index 091cafd..7f3f22e 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/byte8/BSubCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BSubCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.byte8;
+package org.jcnc.snow.vm.commands.type.control.byte8;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
@@ -50,7 +50,7 @@ public class BSubCommand implements Command {
         byte a = (byte) operandStack.pop();
 
         // Perform the subtraction and push the result back onto the stack
-        operandStack.push(a - b);
+        operandStack.push((byte)(a - b));
 
         // Return the updated program counter (next instruction)
         return currentPC + 1;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BXorCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BXorCommand.java
new file mode 100644
index 0000000..478edb9
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/byte8/BXorCommand.java
@@ -0,0 +1,56 @@
+package org.jcnc.snow.vm.commands.type.control.byte8;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+
+/**
+ * The {@code BXorCommand} class implements the {@link Command} interface and represents the byte8 bitwise XOR (`^`) operation command.
+ * This class performs a byte8 bitwise XOR operation in the virtual machine by popping the top two values from the stack,
+ * computing their XOR, and then pushing the result back onto the stack. It is a basic operation command within the virtual machine.
+ *
+ * <p><b>Operation details:</b></p>
+ * <ul>
+ *     <li>Pops two operands from the virtual machine stack.</li>
+ *     <li>Performs the byte8 bitwise XOR (`^`) operation.</li>
+ *     <li>Pushes the result back onto the virtual machine stack.</li>
+ * </ul>
+ */
+public class BXorCommand implements Command {
+    /**
+     * Default constructor for creating an instance of {@code BXorCommand}.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public BXorCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing stack operations.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of method invocations.
+     * @return The updated program counter-value, typically {@code currentPC + 1}, unless a control flow instruction is executed.
+     * @throws IllegalStateException if there are not enough operands on the stack to perform the operation.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Ensure the stack has at least two operands
+        if (operandStack.size() < 2) {
+            throw new IllegalStateException("Not enough operands on the stack for BXOR operation.");
+        }
+
+        // Pop the top two operands from the stack
+        final byte b = (byte) operandStack.pop();
+        final byte a = (byte) operandStack.pop();
+
+        // Perform the byte8 bitwise XOR operation and push the result back onto the stack
+        operandStack.push((byte)(a ^ b));
+
+        return currentPC + 1;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DAddCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DAddCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DAddCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DAddCommand.java
index 76d8b69..470689d 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DAddCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DAddCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.double64;
+package org.jcnc.snow.vm.commands.type.control.double64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCECommand.java
new file mode 100644
index 0000000..a29d018
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.double64;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The DCECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if they are equal, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two double64 from the virtual machine stack.</li>
+ *     <li>If the two double64 are equal, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class DCECommand implements Command {
+    /**
+     * Default constructor for creating an instance of DCECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public DCECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        double b = (double) operandStack.pop();
+        double a = (double) operandStack.pop();
+
+        // If the operands are equal, jump to the target command
+        if (a == b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCGCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCGCommand.java
new file mode 100644
index 0000000..6a35ce6
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCGCommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.double64;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The DCGCommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is greater than the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two double64 from the virtual machine stack.</li>
+ *     <li>If the first double64 is greater than the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class DCGCommand implements Command {
+    /**
+     * Default constructor for creating an instance of DCGCommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public DCGCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        double b = (double) operandStack.pop();
+        double a = (double) operandStack.pop();
+
+        // If the first operand is greater than the second, jump to the target command
+        if (a > b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCGECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCGECommand.java
new file mode 100644
index 0000000..c965492
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCGECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.double64;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The DCGECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is greater than or equal to the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two double64 from the virtual machine stack.</li>
+ *     <li>If the first double64 is greater than or equal to the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class DCGECommand implements Command {
+    /**
+     * Default constructor for creating an instance of DCGECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public DCGECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        double b = (double) operandStack.pop();
+        double a = (double) operandStack.pop();
+
+        // If the first operand is greater than or equal to the second, jump to the target command
+        if (a >= b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCLCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCLCommand.java
new file mode 100644
index 0000000..97167de
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCLCommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.double64;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The DCLCommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is less than the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two double64 from the virtual machine stack.</li>
+ *     <li>If the first double64 is less than the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class DCLCommand implements Command {
+    /**
+     * Default constructor for creating an instance of DCLCommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public DCLCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        double b = (double) operandStack.pop();
+        double a = (double) operandStack.pop();
+
+        // If the first operand is less than the second, jump to the target command
+        if (a < b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCLECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCLECommand.java
new file mode 100644
index 0000000..b43b24a
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCLECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.double64;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The DCLECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is less than or equal to the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two double64 from the virtual machine stack.</li>
+ *     <li>If the first double64 is less than or equal to the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class DCLECommand implements Command {
+    /**
+     * Default constructor for creating an instance of DCLECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public DCLECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        double b = (double) operandStack.pop();
+        double a = (double) operandStack.pop();
+
+        // If the first operand is less than or equal to the second, jump to the target command
+        if (a <= b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCNECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCNECommand.java
new file mode 100644
index 0000000..ff9686e
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DCNECommand.java
@@ -0,0 +1,77 @@
+package org.jcnc.snow.vm.commands.type.control.double64;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The DCNECommand class implements the {@link Command} interface and represents a conditional jump command
+ * in the virtual machine that triggers if two values are not equal.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two double64 from the virtual machine stack.</li>
+ *     <li>If the two double64 are not equal, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class DCNECommand implements Command {
+    /**
+     * Default constructor for creating an instance of DCNECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public DCNECommand() {
+
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        double b = (double) operandStack.pop();
+        double a = (double) operandStack.pop();
+
+        // If the operands are not equal, jump to the target command
+        if (a != b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DDivCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DDivCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DDivCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DDivCommand.java
index 1a70f9a..caeb802 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DDivCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DDivCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.double64;
+package org.jcnc.snow.vm.commands.type.control.double64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DIncCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DIncCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DIncCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DIncCommand.java
index 3f9c672..9af16d5 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DIncCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DIncCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.double64;
+package org.jcnc.snow.vm.commands.type.control.double64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/memory/double64/DLoadCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DLoadCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/memory/double64/DLoadCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DLoadCommand.java
index 9d34e21..bd240d9 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/memory/double64/DLoadCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DLoadCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.memory.double64;
+package org.jcnc.snow.vm.commands.type.control.double64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DModCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DModCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DModCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DModCommand.java
index df8cbd7..a29df4c 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DModCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DModCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.double64;
+package org.jcnc.snow.vm.commands.type.control.double64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DMulCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DMulCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DMulCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DMulCommand.java
index d5adb01..91957c0 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DMulCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DMulCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.double64;
+package org.jcnc.snow.vm.commands.type.control.double64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DNegCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DNegCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DNegCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DNegCommand.java
index 1c36841..934f017 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DNegCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DNegCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.double64;
+package org.jcnc.snow.vm.commands.type.control.double64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/stack/double64/DPushCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DPushCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/stack/double64/DPushCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DPushCommand.java
index 5245d08..b70a7b3 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/stack/double64/DPushCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DPushCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.stack.double64;
+package org.jcnc.snow.vm.commands.type.control.double64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/memory/double64/DStoreCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DStoreCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/memory/double64/DStoreCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DStoreCommand.java
index 7affd8f..9798043 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/memory/double64/DStoreCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DStoreCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.memory.double64;
+package org.jcnc.snow.vm.commands.type.control.double64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DSubCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DSubCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DSubCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DSubCommand.java
index 72d2bda..ccb8f38 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/double64/DSubCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/double64/DSubCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.double64;
+package org.jcnc.snow.vm.commands.type.control.double64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FAddCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FAddCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FAddCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FAddCommand.java
index 3c6e3cb..14ad38f 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FAddCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FAddCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.float32;
+package org.jcnc.snow.vm.commands.type.control.float32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCECommand.java
new file mode 100644
index 0000000..b59cd2e
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.float32;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The FCECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if they are equal, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two float32 from the virtual machine stack.</li>
+ *     <li>If the two float32 are equal, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class FCECommand implements Command {
+    /**
+     * Default constructor for creating an instance of FCECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public FCECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        float b = (float) operandStack.pop();
+        float a = (float) operandStack.pop();
+
+        // If the operands are equal, jump to the target command
+        if (a == b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCGCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCGCommand.java
new file mode 100644
index 0000000..ed49fbd
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCGCommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.float32;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The FCGCommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is greater than the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two float32 from the virtual machine stack.</li>
+ *     <li>If the first float32 is greater than the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class FCGCommand implements Command {
+    /**
+     * Default constructor for creating an instance of FCGCommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public FCGCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        float b = (float) operandStack.pop();
+        float a = (float) operandStack.pop();
+
+        // If the first operand is greater than the second, jump to the target command
+        if (a > b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCGECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCGECommand.java
new file mode 100644
index 0000000..f484bb7
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCGECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.float32;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The FCGECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is greater than or equal to the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two float32 from the virtual machine stack.</li>
+ *     <li>If the first float32 is greater than or equal to the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class FCGECommand implements Command {
+    /**
+     * Default constructor for creating an instance of FCGECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public FCGECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        float b = (float) operandStack.pop();
+        float a = (float) operandStack.pop();
+
+        // If the first operand is greater than or equal to the second, jump to the target command
+        if (a >= b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCLCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCLCommand.java
new file mode 100644
index 0000000..edbfa7e
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCLCommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.float32;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The FCLCommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is less than the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two float32 from the virtual machine stack.</li>
+ *     <li>If the first float32 is less than the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class FCLCommand implements Command {
+    /**
+     * Default constructor for creating an instance of FCLCommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public FCLCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        float b = (float) operandStack.pop();
+        float a = (float) operandStack.pop();
+
+        // If the first operand is less than the second, jump to the target command
+        if (a < b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCLECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCLECommand.java
new file mode 100644
index 0000000..ed910db
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCLECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.float32;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The FCLECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is less than or equal to the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two float32 from the virtual machine stack.</li>
+ *     <li>If the first float32 is less than or equal to the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class FCLECommand implements Command {
+    /**
+     * Default constructor for creating an instance of FCLECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public FCLECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        float b = (float) operandStack.pop();
+        float a = (float) operandStack.pop();
+
+        // If the first operand is less than or equal to the second, jump to the target command
+        if (a <= b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCNECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCNECommand.java
new file mode 100644
index 0000000..a02bd6a
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FCNECommand.java
@@ -0,0 +1,77 @@
+package org.jcnc.snow.vm.commands.type.control.float32;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The FCNECommand class implements the {@link Command} interface and represents a conditional jump command
+ * in the virtual machine that triggers if two values are not equal.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two float32 from the virtual machine stack.</li>
+ *     <li>If the two float32 are not equal, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class FCNECommand implements Command {
+    /**
+     * Default constructor for creating an instance of FCNECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public FCNECommand() {
+
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        float b = (float) operandStack.pop();
+        float a = (float) operandStack.pop();
+
+        // If the operands are not equal, jump to the target command
+        if (a != b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FDivCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FDivCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FDivCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FDivCommand.java
index 5c3fbda..9e7512e 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FDivCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FDivCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.float32;
+package org.jcnc.snow.vm.commands.type.control.float32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FIncCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FIncCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FIncCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FIncCommand.java
index 4061ebd..94c2f2f 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FIncCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FIncCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.float32;
+package org.jcnc.snow.vm.commands.type.control.float32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/memory/float32/FLoadCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FLoadCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/memory/float32/FLoadCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FLoadCommand.java
index 7edcdb6..e0120b3 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/memory/float32/FLoadCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FLoadCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.memory.float32;
+package org.jcnc.snow.vm.commands.type.control.float32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FModCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FModCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FModCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FModCommand.java
index fc0c537..0e35b96 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FModCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FModCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.float32;
+package org.jcnc.snow.vm.commands.type.control.float32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FMulCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FMulCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FMulCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FMulCommand.java
index 34dfd8b..a90e951 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FMulCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FMulCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.float32;
+package org.jcnc.snow.vm.commands.type.control.float32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FNegCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FNegCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FNegCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FNegCommand.java
index 9b28674..89dfd4f 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FNegCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FNegCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.float32;
+package org.jcnc.snow.vm.commands.type.control.float32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/stack/float32/FPushCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FPushCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/stack/float32/FPushCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FPushCommand.java
index da6da33..cb7f6b8 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/stack/float32/FPushCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FPushCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.stack.float32;
+package org.jcnc.snow.vm.commands.type.control.float32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/memory/float32/FStoreCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FStoreCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/memory/float32/FStoreCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FStoreCommand.java
index 4a1ae60..5476e14 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/memory/float32/FStoreCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FStoreCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.memory.float32;
+package org.jcnc.snow.vm.commands.type.control.float32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FSubCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FSubCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FSubCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FSubCommand.java
index dd73714..508a503 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/float32/FSubCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/float32/FSubCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.float32;
+package org.jcnc.snow.vm.commands.type.control.float32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/IAddCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IAddCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/IAddCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IAddCommand.java
index 36375e3..e65c124 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/IAddCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IAddCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/bitwise/int32/IAndCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IAndCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/bitwise/int32/IAndCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IAndCommand.java
index f43b8c6..bf49e74 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/bitwise/int32/IAndCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IAndCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.bitwise.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/control/int32/ICECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICECommand.java
similarity index 95%
rename from src/main/java/org/jcnc/snow/vm/commands/control/int32/ICECommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICECommand.java
index 6e923af..cf35a54 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/control/int32/ICECommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICECommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.control.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.utils.LoggingUtils;
@@ -12,8 +12,8 @@ import org.jcnc.snow.vm.module.OperandStack;
  *
  * <p>Specific behavior:</p>
  * <ul>
- *     <li>Pops two integers from the virtual machine stack.</li>
- *     <li>If the two integers are equal, jumps to the target command.</li>
+ *     <li>Pops two int32 from the virtual machine stack.</li>
+ *     <li>If the two int32 are equal, jumps to the target command.</li>
  *     <li>Otherwise, the program continues with the next command.</li>
  * </ul>
  */
diff --git a/src/main/java/org/jcnc/snow/vm/commands/control/int32/ICGCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICGCommand.java
similarity index 95%
rename from src/main/java/org/jcnc/snow/vm/commands/control/int32/ICGCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICGCommand.java
index a339313..12463a8 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/control/int32/ICGCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICGCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.control.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.utils.LoggingUtils;
@@ -12,8 +12,8 @@ import org.jcnc.snow.vm.module.OperandStack;
  *
  * <p>Specific behavior:</p>
  * <ul>
- *     <li>Pops two integers from the virtual machine stack.</li>
- *     <li>If the first integer is greater than the second, jumps to the target command.</li>
+ *     <li>Pops two int32 from the virtual machine stack.</li>
+ *     <li>If the first int32 is greater than the second, jumps to the target command.</li>
  *     <li>Otherwise, the program continues with the next command.</li>
  * </ul>
  */
diff --git a/src/main/java/org/jcnc/snow/vm/commands/control/int32/ICGECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICGECommand.java
similarity index 94%
rename from src/main/java/org/jcnc/snow/vm/commands/control/int32/ICGECommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICGECommand.java
index 3cfe02d..a689a50 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/control/int32/ICGECommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICGECommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.control.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.utils.LoggingUtils;
@@ -12,8 +12,8 @@ import org.jcnc.snow.vm.module.OperandStack;
  *
  * <p>Specific behavior:</p>
  * <ul>
- *     <li>Pops two integers from the virtual machine stack.</li>
- *     <li>If the first integer is greater than or equal to the second, jumps to the target command.</li>
+ *     <li>Pops two int32 from the virtual machine stack.</li>
+ *     <li>If the first int32 is greater than or equal to the second, jumps to the target command.</li>
  *     <li>Otherwise, the program continues with the next command.</li>
  * </ul>
  */
diff --git a/src/main/java/org/jcnc/snow/vm/commands/control/int32/ICLCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICLCommand.java
similarity index 95%
rename from src/main/java/org/jcnc/snow/vm/commands/control/int32/ICLCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICLCommand.java
index ec3d413..4a56631 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/control/int32/ICLCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICLCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.control.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.utils.LoggingUtils;
@@ -12,8 +12,8 @@ import org.jcnc.snow.vm.module.OperandStack;
  *
  * <p>Specific behavior:</p>
  * <ul>
- *     <li>Pops two integers from the virtual machine stack.</li>
- *     <li>If the first integer is less than the second, jumps to the target command.</li>
+ *     <li>Pops two int32 from the virtual machine stack.</li>
+ *     <li>If the first int32 is less than the second, jumps to the target command.</li>
  *     <li>Otherwise, the program continues with the next command.</li>
  * </ul>
  */
diff --git a/src/main/java/org/jcnc/snow/vm/commands/control/int32/ICLECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICLECommand.java
similarity index 95%
rename from src/main/java/org/jcnc/snow/vm/commands/control/int32/ICLECommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICLECommand.java
index 4e6c007..6de4e40 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/control/int32/ICLECommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICLECommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.control.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.utils.LoggingUtils;
@@ -12,8 +12,8 @@ import org.jcnc.snow.vm.module.OperandStack;
  *
  * <p>Specific behavior:</p>
  * <ul>
- *     <li>Pops two integers from the virtual machine stack.</li>
- *     <li>If the first integer is less than or equal to the second, jumps to the target command.</li>
+ *     <li>Pops two int32 from the virtual machine stack.</li>
+ *     <li>If the first int32 is less than or equal to the second, jumps to the target command.</li>
  *     <li>Otherwise, the program continues with the next command.</li>
  * </ul>
  */
diff --git a/src/main/java/org/jcnc/snow/vm/commands/control/int32/ICNECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICNECommand.java
similarity index 95%
rename from src/main/java/org/jcnc/snow/vm/commands/control/int32/ICNECommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICNECommand.java
index 08a46a9..114d75a 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/control/int32/ICNECommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ICNECommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.control.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.utils.LoggingUtils;
@@ -12,8 +12,8 @@ import org.jcnc.snow.vm.module.OperandStack;
  *
  * <p>Specific behavior:</p>
  * <ul>
- *     <li>Pops two integers from the virtual machine stack.</li>
- *     <li>If the two integers are not equal, jumps to the target command.</li>
+ *     <li>Pops two int32 from the virtual machine stack.</li>
+ *     <li>If the two int32 are not equal, jumps to the target command.</li>
  *     <li>Otherwise, the program continues with the next command.</li>
  * </ul>
  */
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/IDivCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IDivCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/IDivCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IDivCommand.java
index ea5c9cf..e6b0e0d 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/IDivCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IDivCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/IIncCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IIncCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/IIncCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IIncCommand.java
index ac1c150..d95f5aa 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/IIncCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IIncCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/memory/int32/ILoadCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ILoadCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/memory/int32/ILoadCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ILoadCommand.java
index 02a55fa..c4489bd 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/memory/int32/ILoadCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ILoadCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.memory.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/IModCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IModCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/IModCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IModCommand.java
index 0cb9bd0..2692321 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/IModCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IModCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/IMulCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IMulCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/IMulCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IMulCommand.java
index a559759..41078d3 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/IMulCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IMulCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/INegCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/INegCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/INegCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/INegCommand.java
index 2746adb..ee7b9da 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/INegCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/INegCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/bitwise/int32/IOrCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IOrCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/bitwise/int32/IOrCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IOrCommand.java
index 2fe93e3..bc4ed11 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/bitwise/int32/IOrCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IOrCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.bitwise.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/stack/int32/IPushCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IPushCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/stack/int32/IPushCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IPushCommand.java
index 5515e1f..0823557 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/stack/int32/IPushCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IPushCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.stack.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/memory/int32/IStoreCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IStoreCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/memory/int32/IStoreCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IStoreCommand.java
index 31dfb26..6101851 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/memory/int32/IStoreCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IStoreCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.memory.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/ISubCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ISubCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/ISubCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ISubCommand.java
index f910e2b..530b658 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/int32/ISubCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/ISubCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/bitwise/int32/IXorCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IXorCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/bitwise/int32/IXorCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IXorCommand.java
index 0502e0a..a5017bc 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/bitwise/int32/IXorCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/int32/IXorCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.bitwise.int32;
+package org.jcnc.snow.vm.commands.type.control.int32;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LAddCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LAddCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LAddCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LAddCommand.java
index c97a6a1..f46c34d 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LAddCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LAddCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.long64;
+package org.jcnc.snow.vm.commands.type.control.long64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/bitwise/long64/LAndCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LAndCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/bitwise/long64/LAndCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LAndCommand.java
index dd79d10..4cbf00c 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/bitwise/long64/LAndCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LAndCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.bitwise.long64;
+package org.jcnc.snow.vm.commands.type.control.long64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCECommand.java
new file mode 100644
index 0000000..12a0da9
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.long64;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The LCECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if they are equal, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two long64 from the virtual machine stack.</li>
+ *     <li>If the two long64 are equal, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class LCECommand implements Command {
+    /**
+     * Default constructor for creating an instance of LCECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public LCECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        long b = (long) operandStack.pop();
+        long a = (long) operandStack.pop();
+
+        // If the operands are equal, jump to the target command
+        if (a == b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCGCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCGCommand.java
new file mode 100644
index 0000000..03c7b72
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCGCommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.long64;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The LCGCommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is greater than the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two long64 from the virtual machine stack.</li>
+ *     <li>If the first long64 is greater than the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class LCGCommand implements Command {
+    /**
+     * Default constructor for creating an instance of LCGCommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public LCGCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        long b = (long) operandStack.pop();
+        long a = (long) operandStack.pop();
+
+        // If the first operand is greater than the second, jump to the target command
+        if (a > b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCGECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCGECommand.java
new file mode 100644
index 0000000..c5a89d7
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCGECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.long64;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The LCGECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is greater than or equal to the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two long64 from the virtual machine stack.</li>
+ *     <li>If the first long64 is greater than or equal to the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class LCGECommand implements Command {
+    /**
+     * Default constructor for creating an instance of LCGECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public LCGECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        long b = (long) operandStack.pop();
+        long a = (long) operandStack.pop();
+
+        // If the first operand is greater than or equal to the second, jump to the target command
+        if (a >= b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCLCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCLCommand.java
new file mode 100644
index 0000000..8db616a
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCLCommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.long64;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The LCLCommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is less than the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two long64 from the virtual machine stack.</li>
+ *     <li>If the first long64 is less than the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class LCLCommand implements Command {
+    /**
+     * Default constructor for creating an instance of LCLCommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public LCLCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        long b = (long) operandStack.pop();
+        long a = (long) operandStack.pop();
+
+        // If the first operand is less than the second, jump to the target command
+        if (a < b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCLECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCLECommand.java
new file mode 100644
index 0000000..8b86b2b
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCLECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.long64;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The LCLECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is less than or equal to the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two long64 from the virtual machine stack.</li>
+ *     <li>If the first long64 is less than or equal to the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class LCLECommand implements Command {
+    /**
+     * Default constructor for creating an instance of LCLECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public LCLECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        long b = (long) operandStack.pop();
+        long a = (long) operandStack.pop();
+
+        // If the first operand is less than or equal to the second, jump to the target command
+        if (a <= b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCNECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCNECommand.java
new file mode 100644
index 0000000..5bbcacd
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LCNECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.long64;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The LCNECommand class implements the {@link Command} interface and represents a conditional jump command
+ * in the virtual machine that triggers if two values are not equal.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two long64 from the virtual machine stack.</li>
+ *     <li>If the two long64 are not equal, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class LCNECommand implements Command {
+    /**
+     * Default constructor for creating an instance of LCNECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public LCNECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        long b = (long) operandStack.pop();
+        long a = (long) operandStack.pop();
+
+        // If the operands are not equal, jump to the target command
+        if (a != b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LDivCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LDivCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LDivCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LDivCommand.java
index 7d66218..b3b1c62 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LDivCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LDivCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.long64;
+package org.jcnc.snow.vm.commands.type.control.long64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LIncCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LIncCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LIncCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LIncCommand.java
index 18715d3..d374e19 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LIncCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LIncCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.long64;
+package org.jcnc.snow.vm.commands.type.control.long64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/memory/long64/LLoadCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LLoadCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/memory/long64/LLoadCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LLoadCommand.java
index 411d766..f5d81e1 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/memory/long64/LLoadCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LLoadCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.memory.long64;
+package org.jcnc.snow.vm.commands.type.control.long64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LModCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LModCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LModCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LModCommand.java
index 345c2e5..e1174cf 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LModCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LModCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.long64;
+package org.jcnc.snow.vm.commands.type.control.long64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LMulCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LMulCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LMulCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LMulCommand.java
index b5e68aa..1d30635 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LMulCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LMulCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.long64;
+package org.jcnc.snow.vm.commands.type.control.long64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LNegCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LNegCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LNegCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LNegCommand.java
index e93fd1d..aea11d8 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LNegCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LNegCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.long64;
+package org.jcnc.snow.vm.commands.type.control.long64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/bitwise/long64/LOrCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LOrCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/bitwise/long64/LOrCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LOrCommand.java
index 33a9bf9..eb420d8 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/bitwise/long64/LOrCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LOrCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.bitwise.long64;
+package org.jcnc.snow.vm.commands.type.control.long64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/stack/long64/LPushCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LPushCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/stack/long64/LPushCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LPushCommand.java
index d00b9c7..1567897 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/stack/long64/LPushCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LPushCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.stack.long64;
+package org.jcnc.snow.vm.commands.type.control.long64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/memory/long64/LStoreCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LStoreCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/memory/long64/LStoreCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LStoreCommand.java
index f1b5e3f..28e8b13 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/memory/long64/LStoreCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LStoreCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.memory.long64;
+package org.jcnc.snow.vm.commands.type.control.long64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LSubCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LSubCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LSubCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LSubCommand.java
index f710b10..db523e6 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/long64/LSubCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LSubCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.long64;
+package org.jcnc.snow.vm.commands.type.control.long64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/bitwise/long64/LXorCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LXorCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/bitwise/long64/LXorCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LXorCommand.java
index dbce6ab..5aabcfd 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/bitwise/long64/LXorCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/long64/LXorCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.bitwise.long64;
+package org.jcnc.snow.vm.commands.type.control.long64;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SAddCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SAddCommand.java
similarity index 93%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SAddCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SAddCommand.java
index 4137a01..2322639 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SAddCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SAddCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.short16;
+package org.jcnc.snow.vm.commands.type.control.short16;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
@@ -46,11 +46,11 @@ public class SAddCommand implements Command {
     @Override
     public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
         // Pop the top two operands from the stack
-        Short b = (Short) operandStack.pop();
-        Short a = (Short) operandStack.pop();
+        short b = (short) operandStack.pop();
+        short a = (short) operandStack.pop();
 
         // Perform the addition and push the result back onto the stack
-        operandStack.push(a + b);
+        operandStack.push((short)(a + b));
 
         // Return the updated program counter (next instruction)
         return currentPC + 1;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SAndCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SAndCommand.java
new file mode 100644
index 0000000..e2c3d89
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SAndCommand.java
@@ -0,0 +1,56 @@
+package org.jcnc.snow.vm.commands.type.control.short16;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+
+/**
+ * The SAndCommand class implements the {@link Command} interface and represents the short16 bitwise AND (`&`) operation command.
+ * This class performs a short16 bitwise AND operation in the virtual machine by popping the top two values from the stack,
+ * computing their short16 bitwise AND operation, and then pushing the result back onto the stack. It is a basic operation command within the virtual machine.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two operands from the virtual machine stack.</li>
+ *     <li>Performs the short16 bitwise AND (`&`) operation.</li>
+ *     <li>Pushes the result back onto the virtual machine stack.</li>
+ * </ul>
+ */
+public class SAndCommand implements Command {
+    /**
+     * Default constructor for creating an instance of {@code SAndCommand}.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public SAndCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for pushing and popping values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables.
+     * @param callStack          The virtual machine's call stack, used for managing method calls and returns.
+     * @return The updated program counter-value, typically `currentPC + 1` unless a control flow instruction is executed.
+     * @throws IllegalStateException if there are not enough operands on the stack to perform the operation.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Ensure the stack has at least two operands
+        if (operandStack.size() < 2) {
+            throw new IllegalStateException("Not enough operands on the stack for SAND operation.");
+        }
+
+        // Pop the top two operands from the stack
+        final short b = (short) operandStack.pop();
+        final short a = (short) operandStack.pop();
+
+        // Perform the short16 bitwise AND operation and push the result back onto the stack
+        operandStack.push((short)(a & b));
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCECommand.java
new file mode 100644
index 0000000..af95749
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.short16;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The SCECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if they are equal, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two short16 from the virtual machine stack.</li>
+ *     <li>If the two short16 are equal, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class SCECommand implements Command {
+    /**
+     * Default constructor for creating an instance of SCECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public SCECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        short b = (short) operandStack.pop();
+        short a = (short) operandStack.pop();
+
+        // If the operands are equal, jump to the target command
+        if (a == b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCGCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCGCommand.java
new file mode 100644
index 0000000..516247b
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCGCommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.short16;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The SCGCommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is greater than the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two short16 from the virtual machine stack.</li>
+ *     <li>If the first short16 is greater than the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class SCGCommand implements Command {
+    /**
+     * Default constructor for creating an instance of SCGCommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public SCGCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        short b = (short) operandStack.pop();
+        short a = (short) operandStack.pop();
+
+        // If the first operand is greater than the second, jump to the target command
+        if (a > b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCGECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCGECommand.java
new file mode 100644
index 0000000..2e1d0f3
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCGECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.short16;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The SCGECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is greater than or equal to the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two short16 from the virtual machine stack.</li>
+ *     <li>If the first short16 is greater than or equal to the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class SCGECommand implements Command {
+    /**
+     * Default constructor for creating an instance of SCGECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public SCGECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        short b = (short) operandStack.pop();
+        short a = (short) operandStack.pop();
+
+        // If the first operand is greater than or equal to the second, jump to the target command
+        if (a >= b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCLCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCLCommand.java
new file mode 100644
index 0000000..8f54dd9
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCLCommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.short16;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The SCLCommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is less than the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two short16 from the virtual machine stack.</li>
+ *     <li>If the first short16 is less than the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class SCLCommand implements Command {
+    /**
+     * Default constructor for creating an instance of SCLCommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public SCLCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        short b = (short) operandStack.pop();
+        short a = (short) operandStack.pop();
+
+        // If the first operand is less than the second, jump to the target command
+        if (a < b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCLECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCLECommand.java
new file mode 100644
index 0000000..797ce8a
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCLECommand.java
@@ -0,0 +1,76 @@
+package org.jcnc.snow.vm.commands.type.control.short16;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The SCLECommand class implements the {@link Command} interface and represents a conditional jump command in the virtual machine.
+ * This class compares two values from the stack, and if the first value is less than or equal to the second, it jumps to the specified target command.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two short16 from the virtual machine stack.</li>
+ *     <li>If the first short16 is less than or equal to the second, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class SCLECommand implements Command {
+    /**
+     * Default constructor for creating an instance of SCLECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public SCLECommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        short b = (short) operandStack.pop();
+        short a = (short) operandStack.pop();
+
+        // If the first operand is less than or equal to the second, jump to the target command
+        if (a <= b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCNECommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCNECommand.java
new file mode 100644
index 0000000..82d3e5e
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SCNECommand.java
@@ -0,0 +1,77 @@
+package org.jcnc.snow.vm.commands.type.control.short16;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+import org.jcnc.snow.vm.utils.LoggingUtils;
+
+/**
+ * The SCNECommand class implements the {@link Command} interface and represents a conditional jump command
+ * in the virtual machine that triggers if two values are not equal.
+ *
+ * <p>Specific behavior:</p>
+ * <ul>
+ *     <li>Pops two short16 from the virtual machine stack.</li>
+ *     <li>If the two short16 are not equal, jumps to the target command.</li>
+ *     <li>Otherwise, the program continues with the next command.</li>
+ * </ul>
+ */
+public class SCNECommand implements Command {
+    /**
+     * Default constructor for creating an instance of SCNECommand.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public SCNECommand() {
+
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * <p>This method retrieves the necessary data from the virtual machine stack and local variable store based on the instruction's
+     * specific implementation, performs the operation, and updates the program counter (PC) to reflect the next instruction
+     * to be executed.</p>
+     *
+     * <p>The parameters provided allow the command to manipulate the operand stack, modify the local variables, and control the flow
+     * of execution by updating the program counter.</p>
+     *
+     * <p>The exact behavior of this method will depend on the specific instruction being executed (e.g., arithmetic, branching,
+     * function calls, etc.). For example, a `CALL` instruction will modify the call stack by pushing a new frame,
+     * while a `POP` instruction will remove an item from the operand stack.</p>
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments
+     *                           (such as target addresses, values, or function names). These parameters may vary based on
+     *                           the instruction being executed.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     *                           This value is typically incremented after the execution of each instruction to point to the next one.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing operations on the operand stack,
+     *                           such as pushing, popping, and peeking values.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables during instruction execution.
+     *                           The store may not be used in every command but can be leveraged by instructions that require access
+     *                           to local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of the method invocation hierarchy. It is used by
+     *                           instructions that involve method calls or returns (such as `CALL` and `RETURN` instructions).
+     * @return The updated program counter-value, typically the current program counter-value incremented by 1, unless the
+     * instruction modifies control flow (such as a `JUMP` or `CALL`), in which case it may return a new address
+     * corresponding to the target of the jump or the subroutine to call.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Parse the target command address
+        int target = Integer.parseInt(parts[1]);
+
+        // Pop the two operands from the stack
+        short b = (short) operandStack.pop();
+        short a = (short) operandStack.pop();
+
+        // If the operands are not equal, jump to the target command
+        if (a != b) {
+            LoggingUtils.logInfo("Jumping to command", String.valueOf(target));
+            return target;
+        }
+
+        return currentPC + 1;
+    }
+}
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SDivCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SDivCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SDivCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SDivCommand.java
index f14cefa..d8385a2 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SDivCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SDivCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.short16;
+package org.jcnc.snow.vm.commands.type.control.short16;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
@@ -56,7 +56,7 @@ public class SDivCommand implements Command {
         }
 
         // Perform the division and push the result back onto the stack
-        operandStack.push(a / b);
+        operandStack.push((short)(a / b));
 
         // Return the updated program counter (next instruction)
         return currentPC + 1;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SIncCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SIncCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SIncCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SIncCommand.java
index 8da3133..23fc42c 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SIncCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SIncCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.short16;
+package org.jcnc.snow.vm.commands.type.control.short16;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/memory/short16/SLoadCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SLoadCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/memory/short16/SLoadCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SLoadCommand.java
index 6379837..24ddf52 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/memory/short16/SLoadCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SLoadCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.memory.short16;
+package org.jcnc.snow.vm.commands.type.control.short16;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SModCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SModCommand.java
similarity index 96%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SModCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SModCommand.java
index 0047449..1a78486 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SModCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SModCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.short16;
+package org.jcnc.snow.vm.commands.type.control.short16;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
@@ -50,7 +50,7 @@ public class SModCommand implements Command {
         short a = (short) operandStack.pop();
 
         // Perform the modulus operation and push the result back onto the stack
-        operandStack.push(a % b);
+        operandStack.push((short)(a % b));
 
         // Return the updated program counter (next instruction)
         return currentPC + 1;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SMulCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SMulCommand.java
similarity index 96%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SMulCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SMulCommand.java
index 1a2ac4e..49d34d7 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SMulCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SMulCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.short16;
+package org.jcnc.snow.vm.commands.type.control.short16;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
@@ -50,7 +50,7 @@ public class SMulCommand implements Command {
         short a = (short) operandStack.pop();
 
         // Perform the multiplication and push the result back onto the stack
-        operandStack.push(a * b);
+        operandStack.push((short)(a * b));
 
         // Return the updated program counter (next instruction)
         return currentPC + 1;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SNegCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SNegCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SNegCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SNegCommand.java
index 1474c50..6501380 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SNegCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SNegCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.short16;
+package org.jcnc.snow.vm.commands.type.control.short16;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SOrCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SOrCommand.java
new file mode 100644
index 0000000..72a8844
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SOrCommand.java
@@ -0,0 +1,56 @@
+package org.jcnc.snow.vm.commands.type.control.short16;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+
+/**
+ * The {@code SOrCommand} class implements the {@link Command} interface and represents the short16 bitwise OR (`|`) operation command.
+ * This class performs a short16 bitwise OR operation in the virtual machine by popping the top two values from the stack,
+ * computing their OR, and then pushing the result back onto the stack. It is a basic operation command within the virtual machine.
+ *
+ * <p><b>Operation details:</b></p>
+ * <ul>
+ *     <li>Pops two operands from the virtual machine stack.</li>
+ *     <li>Performs the short16 bitwise OR (`|`) operation.</li>
+ *     <li>Pushes the result back onto the virtual machine stack.</li>
+ * </ul>
+ */
+public class SOrCommand implements Command {
+    /**
+     * Default constructor for creating an instance of {@code SOrCommand}.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public SOrCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing stack operations.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of method invocations.
+     * @return The updated program counter-value, typically {@code currentPC + 1}, unless a control flow instruction is executed.
+     * @throws IllegalStateException if there are not enough operands on the stack to perform the operation.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Ensure the stack has at least two operands
+        if (operandStack.size() < 2) {
+            throw new IllegalStateException("Not enough operands on the stack for SOR operation.");
+        }
+
+        // Pop the top two operands from the stack
+        final short b = (short) operandStack.pop();
+        final short a = (short) operandStack.pop();
+
+        // Perform the short16 bitwise OR operation and push the result back onto the stack
+        operandStack.push((short)(a | b));
+
+        return currentPC + 1;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/vm/commands/stack/short16/SPushCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SPushCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/stack/short16/SPushCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SPushCommand.java
index b61fbe2..77af696 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/stack/short16/SPushCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SPushCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.stack.short16;
+package org.jcnc.snow.vm.commands.type.control.short16;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/memory/short16/SStoreCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SStoreCommand.java
similarity index 98%
rename from src/main/java/org/jcnc/snow/vm/commands/memory/short16/SStoreCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SStoreCommand.java
index fb5d79c..a3ea6dd 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/memory/short16/SStoreCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SStoreCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.memory.short16;
+package org.jcnc.snow.vm.commands.type.control.short16;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SSubCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SSubCommand.java
similarity index 96%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SSubCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SSubCommand.java
index 66c3295..d16d0e0 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/short16/SSubCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SSubCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.short16;
+package org.jcnc.snow.vm.commands.type.control.short16;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
@@ -50,7 +50,7 @@ public class SSubCommand implements Command {
         short a = (short) operandStack.pop();
 
         // Perform the subtraction and push the result back onto the stack
-        operandStack.push(a - b);
+        operandStack.push((short)(a - b));
 
         // Return the updated program counter (next instruction)
         return currentPC + 1;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SXorCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SXorCommand.java
new file mode 100644
index 0000000..dd0a8be
--- /dev/null
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/control/short16/SXorCommand.java
@@ -0,0 +1,56 @@
+package org.jcnc.snow.vm.commands.type.control.short16;
+
+import org.jcnc.snow.vm.interfaces.Command;
+import org.jcnc.snow.vm.module.CallStack;
+import org.jcnc.snow.vm.module.LocalVariableStore;
+import org.jcnc.snow.vm.module.OperandStack;
+
+/**
+ * The {@code SXorCommand} class implements the {@link Command} interface and represents the short16 bitwise XOR (`^`) operation command.
+ * This class performs a short16 bitwise XOR operation in the virtual machine by popping the top two values from the stack,
+ * computing their XOR, and then pushing the result back onto the stack. It is a basic operation command within the virtual machine.
+ *
+ * <p><b>Operation details:</b></p>
+ * <ul>
+ *     <li>Pops two operands from the virtual machine stack.</li>
+ *     <li>Performs the short16 bitwise XOR (`^`) operation.</li>
+ *     <li>Pushes the result back onto the virtual machine stack.</li>
+ * </ul>
+ */
+public class SXorCommand implements Command {
+    /**
+     * Default constructor for creating an instance of {@code SXorCommand}.
+     * This constructor is empty as no specific initialization is required.
+     */
+    public SXorCommand() {
+        // Empty constructor
+    }
+
+    /**
+     * Executes the virtual machine instruction's operation.
+     *
+     * @param parts              The array of instruction parameters, which usually includes the operator and related arguments.
+     * @param currentPC          The current program counter-value, indicating the address of the instruction being executed.
+     * @param operandStack       The virtual machine's operand stack manager, responsible for performing stack operations.
+     * @param localVariableStore The local variable store, typically used to manage method-local variables.
+     * @param callStack          The virtual machine's call stack, which keeps track of method invocations.
+     * @return The updated program counter-value, typically {@code currentPC + 1}, unless a control flow instruction is executed.
+     * @throws IllegalStateException if there are not enough operands on the stack to perform the operation.
+     */
+    @Override
+    public int execute(String[] parts, int currentPC, OperandStack operandStack, LocalVariableStore localVariableStore, CallStack callStack) {
+        // Ensure the stack has at least two operands
+        if (operandStack.size() < 2) {
+            throw new IllegalStateException("Not enough operands on the stack for SXOR operation.");
+        }
+
+        // Pop the top two operands from the stack
+        final short b = (short) operandStack.pop();
+        final short a = (short) operandStack.pop();
+
+        // Perform the short16 bitwise XOR operation and push the result back onto the stack
+        operandStack.push((short)(a ^ b));
+
+        return currentPC + 1;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/B2ICommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/B2ICommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/B2ICommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/B2ICommand.java
index 7abd324..c5c18a6 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/B2ICommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/B2ICommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/D2FCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2FCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/D2FCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2FCommand.java
index 3ed687f..7f4bcc0 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/D2FCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2FCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/D2ICommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2ICommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/D2ICommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2ICommand.java
index b0c706c..903f6dc 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/D2ICommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2ICommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/D2LCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2LCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/D2LCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2LCommand.java
index eb38865..78d558a 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/D2LCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/D2LCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/F2DCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2DCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/F2DCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2DCommand.java
index e997502..7f4dba7 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/F2DCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2DCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/F2ICommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2ICommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/F2ICommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2ICommand.java
index 26cf949..24f9192 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/F2ICommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2ICommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/F2LCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2LCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/F2LCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2LCommand.java
index 55abcbc..b4bcb6b 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/F2LCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/F2LCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/I2BCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2BCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/I2BCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2BCommand.java
index 84e2e92..76ef29c 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/I2BCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2BCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/I2DCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2DCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/I2DCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2DCommand.java
index 3653a36..0147f5b 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/I2DCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2DCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/I2FCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2FCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/I2FCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2FCommand.java
index f21e379..22182dc 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/I2FCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2FCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/I2LCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2LCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/I2LCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2LCommand.java
index 9198cfa..a9d1aae 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/I2LCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2LCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/I2SCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2SCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/I2SCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2SCommand.java
index f11f119..ca5987a 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/I2SCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/I2SCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/L2DCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2DCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/L2DCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2DCommand.java
index 7c551db..06426ae 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/L2DCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2DCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/L2FCommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2FCommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/L2FCommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2FCommand.java
index f2cbfc2..5cf6a67 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/L2FCommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2FCommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/L2ICommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2ICommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/L2ICommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2ICommand.java
index ee9f494..f4f4b41 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/L2ICommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/L2ICommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/S2ICommand.java b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2ICommand.java
similarity index 97%
rename from src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/S2ICommand.java
rename to src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2ICommand.java
index 375f0ea..fa3ee74 100644
--- a/src/main/java/org/jcnc/snow/vm/commands/arithmetic/conversion/S2ICommand.java
+++ b/src/main/java/org/jcnc/snow/vm/commands/type/conversion/S2ICommand.java
@@ -1,4 +1,4 @@
-package org.jcnc.snow.vm.commands.arithmetic.conversion;
+package org.jcnc.snow.vm.commands.type.conversion;
 
 import org.jcnc.snow.vm.interfaces.Command;
 import org.jcnc.snow.vm.module.CallStack;
diff --git a/src/main/java/org/jcnc/snow/vm/engine/VMOpCode.java b/src/main/java/org/jcnc/snow/vm/engine/VMOpCode.java
index b3a6680..c53f511 100644
--- a/src/main/java/org/jcnc/snow/vm/engine/VMOpCode.java
+++ b/src/main/java/org/jcnc/snow/vm/engine/VMOpCode.java
@@ -1,45 +1,44 @@
 package org.jcnc.snow.vm.engine;
 
-import org.jcnc.snow.vm.commands.arithmetic.byte8.*;
-import org.jcnc.snow.vm.commands.arithmetic.conversion.*;
-import org.jcnc.snow.vm.commands.arithmetic.double64.*;
-import org.jcnc.snow.vm.commands.arithmetic.float32.*;
-import org.jcnc.snow.vm.commands.arithmetic.int32.*;
-import org.jcnc.snow.vm.commands.arithmetic.long64.*;
-import org.jcnc.snow.vm.commands.arithmetic.short16.*;
-import org.jcnc.snow.vm.commands.bitwise.int32.IAndCommand;
-import org.jcnc.snow.vm.commands.bitwise.int32.IOrCommand;
-import org.jcnc.snow.vm.commands.bitwise.int32.IXorCommand;
-import org.jcnc.snow.vm.commands.bitwise.long64.LAndCommand;
-import org.jcnc.snow.vm.commands.bitwise.long64.LOrCommand;
-import org.jcnc.snow.vm.commands.bitwise.long64.LXorCommand;
-import org.jcnc.snow.vm.commands.control.all.JumpCommand;
-import org.jcnc.snow.vm.commands.control.int32.*;
-import org.jcnc.snow.vm.commands.function.CallCommand;
-import org.jcnc.snow.vm.commands.function.RetCommand;
-import org.jcnc.snow.vm.commands.memory.all.MovCommand;
-import org.jcnc.snow.vm.commands.memory.byte8.BLoadCommand;
-import org.jcnc.snow.vm.commands.memory.byte8.BStoreCommand;
-import org.jcnc.snow.vm.commands.memory.double64.DLoadCommand;
-import org.jcnc.snow.vm.commands.memory.double64.DStoreCommand;
-import org.jcnc.snow.vm.commands.memory.float32.FLoadCommand;
-import org.jcnc.snow.vm.commands.memory.float32.FStoreCommand;
-import org.jcnc.snow.vm.commands.memory.int32.ILoadCommand;
-import org.jcnc.snow.vm.commands.memory.int32.IStoreCommand;
-import org.jcnc.snow.vm.commands.memory.long64.LLoadCommand;
-import org.jcnc.snow.vm.commands.memory.long64.LStoreCommand;
-import org.jcnc.snow.vm.commands.memory.short16.SLoadCommand;
-import org.jcnc.snow.vm.commands.memory.short16.SStoreCommand;
-import org.jcnc.snow.vm.commands.stack.all.DupCommand;
-import org.jcnc.snow.vm.commands.stack.all.PopCommand;
-import org.jcnc.snow.vm.commands.stack.all.SwapCommand;
-import org.jcnc.snow.vm.commands.stack.byte8.BPushCommand;
-import org.jcnc.snow.vm.commands.stack.double64.DPushCommand;
-import org.jcnc.snow.vm.commands.stack.float32.FPushCommand;
-import org.jcnc.snow.vm.commands.stack.int32.IPushCommand;
-import org.jcnc.snow.vm.commands.stack.long64.LPushCommand;
-import org.jcnc.snow.vm.commands.stack.short16.SPushCommand;
-import org.jcnc.snow.vm.commands.vm.HaltCommand;
+import org.jcnc.snow.vm.commands.type.control.byte8.*;
+import org.jcnc.snow.vm.commands.type.control.double64.*;
+import org.jcnc.snow.vm.commands.type.control.float32.*;
+import org.jcnc.snow.vm.commands.type.control.int32.*;
+import org.jcnc.snow.vm.commands.type.control.long64.*;
+import org.jcnc.snow.vm.commands.type.control.short16.*;
+import org.jcnc.snow.vm.commands.type.control.int32.IAndCommand;
+import org.jcnc.snow.vm.commands.type.control.int32.IOrCommand;
+import org.jcnc.snow.vm.commands.type.control.int32.IXorCommand;
+import org.jcnc.snow.vm.commands.type.control.long64.LAndCommand;
+import org.jcnc.snow.vm.commands.type.control.long64.LOrCommand;
+import org.jcnc.snow.vm.commands.type.control.long64.LXorCommand;
+import org.jcnc.snow.vm.commands.flow.control.JumpCommand;
+import org.jcnc.snow.vm.commands.flow.control.CallCommand;
+import org.jcnc.snow.vm.commands.flow.control.RetCommand;
+import org.jcnc.snow.vm.commands.register.control.MovCommand;
+import org.jcnc.snow.vm.commands.type.control.byte8.BLoadCommand;
+import org.jcnc.snow.vm.commands.type.control.byte8.BStoreCommand;
+import org.jcnc.snow.vm.commands.type.control.double64.DLoadCommand;
+import org.jcnc.snow.vm.commands.type.control.double64.DStoreCommand;
+import org.jcnc.snow.vm.commands.type.control.float32.FLoadCommand;
+import org.jcnc.snow.vm.commands.type.control.float32.FStoreCommand;
+import org.jcnc.snow.vm.commands.type.control.int32.ILoadCommand;
+import org.jcnc.snow.vm.commands.type.control.int32.IStoreCommand;
+import org.jcnc.snow.vm.commands.type.control.long64.LLoadCommand;
+import org.jcnc.snow.vm.commands.type.control.long64.LStoreCommand;
+import org.jcnc.snow.vm.commands.type.control.short16.SLoadCommand;
+import org.jcnc.snow.vm.commands.type.control.short16.SStoreCommand;
+import org.jcnc.snow.vm.commands.stack.control.DupCommand;
+import org.jcnc.snow.vm.commands.stack.control.PopCommand;
+import org.jcnc.snow.vm.commands.stack.control.SwapCommand;
+import org.jcnc.snow.vm.commands.type.control.byte8.BPushCommand;
+import org.jcnc.snow.vm.commands.type.control.double64.DPushCommand;
+import org.jcnc.snow.vm.commands.type.control.float32.FPushCommand;
+import org.jcnc.snow.vm.commands.type.control.int32.IPushCommand;
+import org.jcnc.snow.vm.commands.type.control.long64.LPushCommand;
+import org.jcnc.snow.vm.commands.type.control.short16.SPushCommand;
+import org.jcnc.snow.vm.commands.type.conversion.*;
+import org.jcnc.snow.vm.commands.system.control.HaltCommand;
 import org.jcnc.snow.vm.module.LocalVariableStore;
 
 /**
@@ -47,88 +46,103 @@ import org.jcnc.snow.vm.module.LocalVariableStore;
  * <p>Each opcode represents a specific operation executed by the virtual machine.</p>
  */
 public class VMOpCode {
-    // 1   Arithmetic Operations (1–80)
-    // 1.1 int32 (1-10)
+
+    // region Type Control (0x0000-0x00BF)
+    // region Byte8	 (0x0000-0x001F)
     /**
-     * I_ADD Opcode: Represents the int32 addition operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link IAddCommand} class, which defines its specific execution logic.</p>
+     * B_ADD Opcode: Represents the byte8 addition operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link BAddCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top two int32 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
-     *     <li>Performs the addition operation on these two int32s.</li>
+     *     <li>Pops the top two byte8 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
+     *     <li>Performs the addition operation on these two byte8 values.</li>
      *     <li>Pushes the result of the addition back onto the operand stack for later instructions to use.</li>
      * </ol>
      *
      * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic int32 addition tasks.</p>
+     * primarily used to handle basic byte8 addition tasks.</p>
      */
-    public static final int I_ADD = 1;
+    public static final int B_ADD = 0x0000;
     /**
-     * I_SUB Opcode: Represents the int32 subtraction operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link ISubCommand} class, which defines its specific execution logic.</p>
+     * B_SUB Opcode: Represents the byte8 subtraction operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link BSubCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top two int32 values from the operand stack (the first value popped is the subtrahend, and the second value popped is the minuend).</li>
+     *     <li>Pops the top two byte8 values from the operand stack (the first value popped is the subtrahend, and the second value popped is the minuend).</li>
      *     <li>Performs the subtraction operation by subtracting the subtrahend from the minuend (i.e., <code>minuend - subtrahend</code>).</li>
      *     <li>Pushes the result of the subtraction back onto the operand stack for later instructions to use.</li>
      * </ol>
      *
      * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic int32 subtraction tasks.</p>
+     * primarily used to handle basic byte8 subtraction tasks.</p>
      */
-    public static final int I_SUB = 2;
+    public static final int B_SUB = 0x0001;
     /**
-     * I_MUL Opcode: Represents the int32 multiplication operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link IMulCommand} class, which defines its specific execution logic.</p>
+     * B_MUL Opcode: Represents the byte8 multiplication operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link BMulCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top two int32 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
-     *     <li>Performs the multiplication operation on these two int32s (i.e., <code>firstOperand * secondOperand</code>).</li>
+     *     <li>Pops the top two byte8 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
+     *     <li>Performs the multiplication operation on these two byte8 values (i.e., <code>firstOperand * secondOperand</code>).</li>
      *     <li>Pushes the result of the multiplication back onto the operand stack for later instructions to use.</li>
      * </ol>
      *
      * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic int32 multiplication tasks.</p>
+     * primarily used to handle basic byte8 multiplication tasks.</p>
      */
-    public static final int I_MUL = 3;
+    public static final int B_MUL = 0x0002;
     /**
-     * I_DIV Opcode: Represents the int32 division operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link IDivCommand} class, which defines its specific execution logic.</p>
+     * B_DIV Opcode: Represents the byte8 division operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link BDivCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top two int32 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
+     *     <li>Pops the top two byte8 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
      *     <li>Performs the division operation by dividing the dividend by the divisor (i.e., <code>dividend / divisor</code>).</li>
      *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
      *     <li>Pushes the result of the division back onto the operand stack for later instructions to use.</li>
      * </ol>
      *
      * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic int32 division tasks.</p>
+     * primarily used to handle basic byte8 division tasks.</p>
      */
-    public static final int I_DIV = 4;
+    public static final int B_DIV = 0x0003;
     /**
-     * I_MOD Opcode: Represents the int32 modulus (remainder) operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link IModCommand} class, which defines its specific execution logic.</p>
+     * B_MOD Opcode: Represents the byte8 modulus (remainder) operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link BModCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top two int32 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
+     *     <li>Pops the top two byte8 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
      *     <li>Performs the modulus operation by calculating the remainder of the division of the dividend by the divisor (i.e., <code>dividend % divisor</code>).</li>
      *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
      *     <li>Pushes the result of the modulus operation back onto the operand stack for later instructions to use.</li>
      * </ol>
      *
      * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic int32 modulus (remainder)  tasks.</p>
+     * primarily used to handle basic byte8 modulus (remainder) tasks.</p>
      */
-    public static final int I_MOD = 5;
+    public static final int B_MOD = 0x0004;
     /**
-     * I_INC Opcode: Represents the int32 increment operation for a local variable in the virtual machine.
-     * <p>This opcode is implemented by the {@link IIncCommand} class, which defines its specific execution logic.</p>
+     * B_NEG Opcode: Represents the byte8 negation operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link BNegCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top byte8 value from the operand stack.</li>
+     *     <li>Performs the negation of the popped value (i.e., <code>-value</code>).</li>
+     *     <li>Pushes the negated result back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is typically used to negate a byte8 value, making it a fundamental operation for arithmetic logic within the virtual machine.</p>
+     */
+    public static final int B_NEG = 0x0005;
+    /**
+     * B_INC Opcode: Represents the byte8 increment operation for a local variable in the virtual machine.
+     * <p>This opcode is implemented by the {@link BIncCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
@@ -140,158 +154,255 @@ public class VMOpCode {
      *     <li>Returns the updated program counter (PC) value, typically incremented by 1, unless control flow changes.</li>
      * </ol>
      *
-     * <p>This opcode is particularly useful for optimizing scenarios where a local variable, such as a counter or loop index, is frequently incremented.</p>
+     * <p>This opcode is particularly useful for optimizing scenarios where a local `byte8` variable, such as a counter or loop index, is frequently incremented.</p>
      */
-    public static final int I_INC = 6;
-
+    public static final int B_INC = 0x0006;
     /**
-     * I_NEG Opcode: Represents the int32 negation operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link INegCommand} class, which defines its specific execution logic.</p>
+     * I_AND Opcode: Represents the byte8 bitwise AND operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link IAndCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top int32 value from the operand stack.</li>
-     *     <li>Performs the negation of the popped value (i.e., <code>-value</code>).</li>
-     *     <li>Pushes the negated result back onto the operand stack for later instructions to use.</li>
+     *     <li>Pops the top two byte8 values from the operand stack. These values are treated as 32-bit binary representations.</li>
+     *     <li>Performs the byte8 bitwise AND operation on the two popped operands. The operation compares corresponding bits of both operands:
+     *         <ul>
+     *             <li>Each bit in the result is set to <code>1</code> only if the corresponding bits in both operands are also <code>1</code>.</li>
+     *             <li>If either of the corresponding bits is <code>0</code>, the resulting bit is <code>0</code>.</li>
+     *         </ul>
+     *     </li>
+     *     <li>Pushes the result of the byte8 bitwise AND operation back onto the operand stack for further processing.</li>
      * </ol>
      *
-     * <p>This opcode is typically used to negate an int32 value, making it a fundamental operation for arithmetic logic within the virtual machine.</p>
+     * <p>This opcode is essential for low-level bit manipulation tasks.</p>
      */
-    public static final int I_NEG = 7;
-    // 1.2 long64 (11-20)
+    public static final int B_AND = 0x0007;
     /**
-     * L_ADD Opcode: Represents the long64 addition operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link LAddCommand} class, which defines its specific execution logic.</p>
+     * I_OR Opcode: Represents the byte8 bitwise OR operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link IOrCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top two long64 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
-     *     <li>Performs the addition operation on these two long64s.</li>
-     *     <li>Pushes the result of the addition back onto the operand stack for later instructions to use.</li>
+     *     <li>Pops the top two byte8 values from the operand stack. These values are treated as 32-bit binary representations.</li>
+     *     <li>Performs the byte8 bitwise OR operation on the two popped operands. The operation compares corresponding bits of both operands:
+     *         <ul>
+     *             <li>Each bit in the result is set to <code>1</code> if at least one of the corresponding bits in either operand is <code>1</code>.</li>
+     *             <li>If both corresponding bits are <code>0</code>, the resulting bit is <code>0</code>.</li>
+     *         </ul>
+     *     </li>
+     *     <li>Pushes the result of the byte8 bitwise OR operation back onto the operand stack for further processing.</li>
      * </ol>
      *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic long64 addition tasks.</p>
+     * <p>This opcode is essential for low-level bit manipulation tasks.</p>
      */
-    public static final int L_ADD = 11;
-
+    public static final int B_OR = 0x0008;
     /**
-     * L_SUB Opcode: Represents the long64 subtraction operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link LSubCommand} class, which defines its specific execution logic.</p>
+     * I_XOR Opcode: Represents the byte8 bitwise XOR operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link IXorCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top two long64 values from the operand stack (the first value popped is the subtrahend, and the second value popped is the minuend).</li>
-     *     <li>Performs the subtraction operation by subtracting the subtrahend from the minuend (i.e., <code>minuend - subtrahend</code>).</li>
-     *     <li>Pushes the result of the subtraction back onto the operand stack for later instructions to use.</li>
+     *     <li>Pops the top two byte8 values from the operand stack. These values are treated as 32-bit binary representations.</li>
+     *     <li>Performs the byte8 bitwise XOR (exclusive OR) operation on the two operands:
+     *         <ul>
+     *             <li>If the corresponding bits are different, the result is <code>1</code>.</li>
+     *             <li>If the corresponding bits are the same, the result is <code>0</code>.</li>
+     *         </ul>
+     *     </li>
+     *     <li>Pushes the result of the byte8 bitwise XOR operation back onto the operand stack for further processing.</li>
      * </ol>
      *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic long64 subtraction tasks.</p>
+     * <p>This opcode is essential for low-level bit manipulation tasks.</p>
      */
-    public static final int L_SUB = 12;
-
+    public static final int B_XOR = 0x0009;
     /**
-     * L_MUL Opcode: Represents the long64 multiplication operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link LMulCommand} class, which defines its specific execution logic.</p>
+     * B_PUSH Opcode: Represents a stack operation that pushes a byte8 value onto the operand stack.
+     * <p>This opcode is implemented by the {@link BPushCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top two long64 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
-     *     <li>Performs the multiplication operation on these two long64s (i.e., <code>firstOperand * secondOperand</code>).</li>
-     *     <li>Pushes the result of the multiplication back onto the operand stack for later instructions to use.</li>
+     *     <li>Parses the byte8 value from the instruction parameters.</li>
+     *     <li>Pushes the parsed byte8 value onto the operand stack.</li>
+     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
      * </ol>
      *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic long64 multiplication tasks.</p>
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Loading constant values into the operand stack for later operations.</li>
+     *     <li>Preparing operands for arithmetic, logical, or comparison instructions.</li>
+     *     <li>Facilitating method calls or control flow by managing stack-based data.</li>
+     * </ul>
      */
-    public static final int L_MUL = 13;
-
+    public static final int B_PUSH = 0x000A;
     /**
-     * L_DIV Opcode: Represents the long64 division operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link LDivCommand} class, which defines its specific execution logic.</p>
+     * B_LOAD Opcode: Represents a load operation that retrieves a byte8 value from the local variable store and pushes it onto the operand stack.
+     * <p>This opcode is implemented by the {@link BLoadCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top two long64 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
-     *     <li>Performs the division operation by dividing the dividend by the divisor (i.e., <code>dividend / divisor</code>).</li>
-     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
-     *     <li>Pushes the result of the division back onto the operand stack for later instructions to use.</li>
+     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
+     *     <li>Retrieves the corresponding value from the local variable store of the current method frame.</li>
+     *     <li>Pushes the retrieved value onto the operand stack for subsequent operations.</li>
+     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
      * </ol>
      *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic long64 division tasks.</p>
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Loading local variables onto the operand stack for further operations or computations.</li>
+     *     <li>Retrieving stored values that are needed for subsequent instructions, such as arithmetic or logic operations.</li>
+     *     <li>Preserving the necessary method-local state by pushing relevant values from the local variable store to the operand stack.</li>
+     * </ul>
      */
-    public static final int L_DIV = 14;
-
+    public static final int B_LOAD = 0x000B;
     /**
-     * L_MOD Opcode: Represents the long64 modulus (remainder) operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link LModCommand} class, which defines its specific execution logic.</p>
+     * B_STORE Opcode: Represents a store operation that stores a byte8 value from the operand stack into the local variable store.
+     * <p>This opcode is implemented by the {@link BStoreCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top two long64 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
-     *     <li>Performs the modulus operation by calculating the remainder of the division of the dividend by the divisor (i.e., <code>dividend % divisor</code>).</li>
-     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
-     *     <li>Pushes the result of the modulus operation back onto the operand stack for later instructions to use.</li>
+     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
+     *     <li>Pops a byte8 value from the operand stack.</li>
+     *     <li>Stores the value into the local variable store at the specified index of the current method frame.</li>
+     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
      * </ol>
      *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic long64 modulus (remainder) tasks.</p>
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Saving byte8 results or constants into method-local variables.</li>
+     *     <li>Enabling byte-level operations and temporary storage.</li>
+     *     <li>Transferring values from the stack to local scope in compact form.</li>
+     * </ul>
      */
-    public static final int L_MOD = 15;
-
+    public static final int B_STORE = 0x000C;
     /**
-     * L_INC Opcode: Represents the long64 increment operation for a local variable in the virtual machine.
-     * <p>This opcode is implemented by the {@link LIncCommand} class, which defines its specific execution logic.</p>
+     * I_CE Opcode: Represents a conditional jump based on byte8 equality.
+     * <p>This opcode is implemented by the {@link ICECommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Retrieves the index of the local variable and the increment value from the instruction parameters.</li>
-     *     <li>Gets the current value of the local variable at the specified index from the local variable store.</li>
-     *     <li>Increments the local variable's value by the specified increment (i.e.,
-     *         <code>localVariables[index] += increment</code>).</li>
-     *     <li>Updates the local variable store with the new incremented value.</li>
-     *     <li>Returns the updated program counter (PC) value, typically incremented by 1, unless control flow changes.</li>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two byte8 values from the operand stack.</li>
+     *     <li>Compares the two byte8 for equality.</li>
+     *     <li>If the byte8 are equal, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the byte8 are not equal, increments the program counter to proceed with the next sequential instruction.</li>
      * </ol>
      *
-     * <p>This opcode is particularly useful for optimizing scenarios where a local `long64` variable, such as a counter or loop index, is frequently incremented.</p>
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on byte8 comparison.</li>
+     *     <li>Implementing control flow structures such as if-statements and loops.</li>
+     * </ul>
      */
-    public static final int L_INC = 16;
-
-
+    public static final int B_CE = 0x000D;
     /**
-     * L_NEG Opcode: Represents the long64 negation operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link LNegCommand} class, which defines its specific execution logic.</p>
+     * I_CNE Opcode: Represents a conditional jump based on byte8 inequality.
+     * <p>This opcode is implemented by the {@link ICNECommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top long64 value from the operand stack.</li>
-     *     <li>Performs the negation of the popped value (i.e., <code>-value</code>).</li>
-     *     <li>Pushes the negated result back onto the operand stack for later instructions to use.</li>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two byte8 values from the operand stack.</li>
+     *     <li>Compares the two byte8 for inequality.</li>
+     *     <li>If the byte8 are not equal, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the byte8 are equal, increments the program counter to proceed with the next sequential instruction.</li>
      * </ol>
      *
-     * <p>This opcode is typically used to negate a long64 value, making it a fundamental operation for arithmetic logic within the virtual machine.</p>
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on byte8 comparison.</li>
+     *     <li>Implementing control flow structures such as conditional loops and if-else statements.</li>
+     * </ul>
      */
-    public static final int L_NEG = 17;
-
-    // 1.3 short16 (21-30)
+    public static final int B_CNE = 0x000E;
     /**
-     * S_ADD Opcode: Represents the short16 addition operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link SAddCommand} class, which defines its specific execution logic.</p>
+     * I_CG Opcode: Represents a conditional jump based on byte8 comparison (greater than).
+     * <p>This opcode is implemented by the {@link ICGCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top two short16 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
-     *     <li>Performs the addition operation on these two short16 values.</li>
-     *     <li>Pushes the result of the addition back onto the operand stack for later instructions to use.</li>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two byte8 values from the operand stack.</li>
+     *     <li>Compares the first byte8 with the second to determine if it is greater.</li>
+     *     <li>If the first byte8 is greater than the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first byte8 is not greater than the second, increments the program counter to proceed with the next sequential instruction.</li>
      * </ol>
      *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic short16 addition tasks.</p>
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on byte8 comparison.</li>
+     *     <li>Implementing control flow structures such as greater-than conditions in loops and conditional statements.</li>
+     * </ul>
      */
-    public static final int S_ADD = 21;
+    public static final int B_CG = 0x000F;
+    /**
+     * I_CGE Opcode: Represents a conditional jump based on byte8 comparison (greater than or equal to).
+     * <p>This opcode is implemented by the {@link ICGECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two byte8 values from the operand stack.</li>
+     *     <li>Compares the first byte8 with the second to determine if it is greater than or equal to the second byte8.</li>
+     *     <li>If the first byte8 is greater than or equal to the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first byte8 is less than the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on byte8 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and range checks.</li>
+     * </ul>
+     */
+    public static final int B_CGE = 0x0010;
+    /**
+     * I_CL Opcode: Represents a conditional jump based on byte8 comparison (less than).
+     * <p>This opcode is implemented by the {@link ICLCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two byte8 values from the operand stack.</li>
+     *     <li>Compares the first byte8 with the second to determine if it is less than the second byte8.</li>
+     *     <li>If the first byte8 is less than the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first byte8 is greater than or equal to the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on byte8 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and range validations.</li>
+     * </ul>
+     */
+    public static final int B_CL = 0x0011;
+    /**
+     * B_CLE Opcode: Represents a conditional jump based on byte8 comparison (less than or equal).
+     * <p>This opcode is implemented by the {@link ICLECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two byte8 values from the operand stack.</li>
+     *     <li>Compares the first byte8 with the second to determine if it is less than or equal to the second byte8.</li>
+     *     <li>If the first byte8 is less than or equal to the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first byte8 is greater than the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on byte8 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and boundary checks.</li>
+     * </ul>
+     */
+    public static final int B_CLE = 0x0012;
+    // endregion
 
+    // region Short16 (0x0020-0x003F)
+    public static final int S_ADD = 0x0020;
     /**
      * S_SUB Opcode: Represents the short16 subtraction operation in the virtual machine.
      * <p>This opcode is implemented by the {@link SSubCommand} class, which defines its specific execution logic.</p>
@@ -306,8 +417,7 @@ public class VMOpCode {
      * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
      * primarily used to handle basic short16 subtraction tasks.</p>
      */
-    public static final int S_SUB = 22;
-
+    public static final int S_SUB = 0x0021;
     /**
      * S_MUL Opcode: Represents the short16 multiplication operation in the virtual machine.
      * <p>This opcode is implemented by the {@link SMulCommand} class, which defines its specific execution logic.</p>
@@ -322,8 +432,7 @@ public class VMOpCode {
      * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
      * primarily used to handle basic short16 multiplication tasks.</p>
      */
-    public static final int S_MUL = 23;
-
+    public static final int S_MUL = 0x0022;
     /**
      * S_DIV Opcode: Represents the short16 division operation in the virtual machine.
      * <p>This opcode is implemented by the {@link SDivCommand} class, which defines its specific execution logic.</p>
@@ -339,8 +448,7 @@ public class VMOpCode {
      * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
      * primarily used to handle basic short16 division tasks.</p>
      */
-    public static final int S_DIV = 24;
-
+    public static final int S_DIV = 0x0023;
     /**
      * S_MOD Opcode: Represents the short16 modulus (remainder) operation in the virtual machine.
      * <p>This opcode is implemented by the {@link SModCommand} class, which defines its specific execution logic.</p>
@@ -356,8 +464,21 @@ public class VMOpCode {
      * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
      * primarily used to handle basic short16 modulus (remainder) tasks.</p>
      */
-    public static final int S_MOD = 25;
-
+    public static final int S_MOD = 0x0024;
+    /**
+     * S_NEG Opcode: Represents the short16 negation operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link SNegCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top short16 value from the operand stack.</li>
+     *     <li>Performs the negation of the popped value (i.e., <code>-value</code>).</li>
+     *     <li>Pushes the negated result back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is typically used to negate a short16 value, making it a fundamental operation for arithmetic logic within the virtual machine.</p>
+     */
+    public static final int S_NEG = 0x0025;
     /**
      * S_INC Opcode: Represents the short16 increment operation in the virtual machine.
      * <p>This opcode is implemented by the {@link SIncCommand} class, which defines its specific execution logic.</p>
@@ -375,918 +496,64 @@ public class VMOpCode {
      * <p>This opcode is useful for scenarios where a local variable needs to be incremented, such as counters within loops,
      * or for optimizing the modification of variables in tight loops.</p>
      */
-    public static final int S_INC = 26;
-
+    public static final int S_INC = 0x0026;
     /**
-     * S_NEG Opcode: Represents the short16 negation operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link SNegCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top short16 value from the operand stack.</li>
-     *     <li>Performs the negation of the popped value (i.e., <code>-value</code>).</li>
-     *     <li>Pushes the negated result back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is typically used to negate a short16 value, making it a fundamental operation for arithmetic logic within the virtual machine.</p>
-     */
-    public static final int S_NEG = 27;
-
-    // 1.4 byte8 (31-40)
-    /**
-     * B_ADD Opcode: Represents the byte8 addition operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link BAddCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two byte8 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
-     *     <li>Performs the addition operation on these two byte8 values.</li>
-     *     <li>Pushes the result of the addition back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic byte8 addition tasks.</p>
-     */
-    public static final int B_ADD = 31;
-
-    /**
-     * B_SUB Opcode: Represents the byte8 subtraction operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link BSubCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two byte8 values from the operand stack (the first value popped is the subtrahend, and the second value popped is the minuend).</li>
-     *     <li>Performs the subtraction operation by subtracting the subtrahend from the minuend (i.e., <code>minuend - subtrahend</code>).</li>
-     *     <li>Pushes the result of the subtraction back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic byte8 subtraction tasks.</p>
-     */
-    public static final int B_SUB = 32;
-
-    /**
-     * B_MUL Opcode: Represents the byte8 multiplication operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link BMulCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two byte8 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
-     *     <li>Performs the multiplication operation on these two byte8 values (i.e., <code>firstOperand * secondOperand</code>).</li>
-     *     <li>Pushes the result of the multiplication back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic byte8 multiplication tasks.</p>
-     */
-    public static final int B_MUL = 33;
-
-    /**
-     * B_DIV Opcode: Represents the byte8 division operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link BDivCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two byte8 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
-     *     <li>Performs the division operation by dividing the dividend by the divisor (i.e., <code>dividend / divisor</code>).</li>
-     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
-     *     <li>Pushes the result of the division back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic byte8 division tasks.</p>
-     */
-    public static final int B_DIV = 34;
-
-    /**
-     * B_MOD Opcode: Represents the byte8 modulus (remainder) operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link BModCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two byte8 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
-     *     <li>Performs the modulus operation by calculating the remainder of the division of the dividend by the divisor (i.e., <code>dividend % divisor</code>).</li>
-     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
-     *     <li>Pushes the result of the modulus operation back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic byte8 modulus (remainder) tasks.</p>
-     */
-    public static final int B_MOD = 35;
-
-    /**
-     * B_INC Opcode: Represents the byte8 increment operation for a local variable in the virtual machine.
-     * <p>This opcode is implemented by the {@link BIncCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Retrieves the index of the local variable and the increment value from the instruction parameters.</li>
-     *     <li>Gets the current value of the local variable at the specified index from the local variable store.</li>
-     *     <li>Increments the local variable's value by the specified increment (i.e.,
-     *         <code>localVariables[index] += increment</code>).</li>
-     *     <li>Updates the local variable store with the new incremented value.</li>
-     *     <li>Returns the updated program counter (PC) value, typically incremented by 1, unless control flow changes.</li>
-     * </ol>
-     *
-     * <p>This opcode is particularly useful for optimizing scenarios where a local `byte8` variable, such as a counter or loop index, is frequently incremented.</p>
-     */
-    public static final int B_INC = 36;
-
-
-    /**
-     * B_NEG Opcode: Represents the byte8 negation operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link BNegCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top byte8 value from the operand stack.</li>
-     *     <li>Performs the negation of the popped value (i.e., <code>-value</code>).</li>
-     *     <li>Pushes the negated result back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is typically used to negate a byte8 value, making it a fundamental operation for arithmetic logic within the virtual machine.</p>
-     */
-    public static final int B_NEG = 37;
-
-    // 1.5 double64 (41-50)
-    /**
-     * D_ADD Opcode: Represents the double64 precision floating-point addition operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link DAddCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two double64 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
-     *     <li>Performs the double64 precision floating-point addition operation on these two operands.</li>
-     *     <li>Pushes the result of the addition back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic double64 precision floating-point addition tasks.</p>
-     */
-    public static final int D_ADD = 41;
-
-    /**
-     * D_SUB Opcode: Represents the double64 precision floating-point subtraction operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link DSubCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two double64 values from the operand stack (the first value popped is the subtrahend, and the second value popped is the minuend).</li>
-     *     <li>Performs the double64 precision floating-point subtraction operation by subtracting the subtrahend from the minuend (i.e., <code>minuend - subtrahend</code>).</li>
-     *     <li>Pushes the result of the subtraction back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic double64 precision floating-point subtraction tasks.</p>
-     */
-    public static final int D_SUB = 42;
-
-    /**
-     * D_MUL Opcode: Represents the double64 precision floating-point multiplication operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link DMulCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two double64 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
-     *     <li>Performs the double64 precision floating-point multiplication operation on these two operands (i.e., <code>firstOperand * secondOperand</code>).</li>
-     *     <li>Pushes the result of the multiplication back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic double64 precision floating-point multiplication tasks.</p>
-     */
-    public static final int D_MUL = 43;
-
-    /**
-     * D_DIV Opcode: Represents the double64 precision floating-point division operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link DDivCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two double64 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
-     *     <li>Performs the double64 precision floating-point division operation by dividing the dividend by the divisor (i.e., <code>dividend / divisor</code>).</li>
-     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
-     *     <li>Pushes the result of the division back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic double64 precision floating-point division tasks.</p>
-     */
-    public static final int D_DIV = 44;
-
-    /**
-     * D_MOD Opcode: Represents the double64 precision floating-point modulus (remainder) operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link DModCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two double64 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
-     *     <li>Performs the modulus operation by calculating the remainder of the division of the dividend by the divisor (i.e., <code>dividend % divisor</code>).</li>
-     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
-     *     <li>Pushes the result of the modulus operation back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic double64 precision floating-point modulus (remainder) tasks.</p>
-     */
-    public static final int D_MOD = 45;
-
-    /**
-     * D_INC Opcode: Represents the double64 increment operation for a local variable in the virtual machine.
-     * <p>This opcode is implemented by the {@link DIncCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Retrieves the index of the local variable and the increment value from the instruction parameters.</li>
-     *     <li>Gets the current value of the local variable at the specified index from the local variable store.</li>
-     *     <li>Increments the local variable's value by the specified increment (i.e.,
-     *         <code>localVariables[index] += increment</code>).</li>
-     *     <li>Updates the local variable store with the new incremented value.</li>
-     *     <li>Returns the updated program counter (PC) value, typically incremented by 1, unless control flow changes.</li>
-     * </ol>
-     *
-     * <p>This opcode is particularly useful for optimizing scenarios where a local `double64` variable, such as a counter or loop index, is frequently incremented.</p>
-     */
-    public static final int D_INC = 46;
-
-    /**
-     * D_NEG Opcode: Represents the double64 precision floating-point negation operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link DNegCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top double64 value from the operand stack.</li>
-     *     <li>Performs the negation of the popped value (i.e., <code>-value</code>).</li>
-     *     <li>Pushes the negated result back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is typically used to negate a double64 precision floating-point value, making it a fundamental operation for double64 precision arithmetic logic within the virtual machine.</p>
-     */
-    public static final int D_NEG = 47;
-
-    // 1.6 float32 (51-60)
-    /**
-     * F_ADD Opcode: Represents the float32 addition operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link FAddCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two float32 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
-     *     <li>Performs the float32 addition operation on these two operands.</li>
-     *     <li>Pushes the result of the addition back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic float32 addition tasks.</p>
-     */
-    public static final int F_ADD = 51;
-    /**
-     * F_SUB Opcode: Represents the float32 subtraction operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link FSubCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two float32 values from the operand stack (the first value popped is the subtrahend, and the second value popped is the minuend).</li>
-     *     <li>Performs the float32 subtraction operation by subtracting the subtrahend from the minuend (i.e., <code>minuend - subtrahend</code>).</li>
-     *     <li>Pushes the result of the subtraction back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic float32 subtraction tasks.</p>
-     */
-    public static final int F_SUB = 52;
-    /**
-     * F_MUL Opcode: Represents the float32 multiplication operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link FMulCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two float32 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
-     *     <li>Performs the float32 multiplication operation on these two operands (i.e., <code>firstOperand * secondOperand</code>).</li>
-     *     <li>Pushes the result of the multiplication back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic float32 multiplication tasks.</p>
-     */
-    public static final int F_MUL = 53;
-    /**
-     * F_DIV Opcode: Represents the float32 division operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link FDivCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two float32 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
-     *     <li>Performs the float32 division operation by dividing the dividend by the divisor (i.e., <code>dividend / divisor</code>).</li>
-     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
-     *     <li>Pushes the result of the division back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic float32 division tasks.</p>
-     */
-    public static final int F_DIV = 54;
-    /**
-     * F_MOD Opcode: Represents the float32 modulus (remainder) operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link FModCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two float32 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
-     *     <li>Performs the modulus operation by calculating the remainder of the division of the dividend by the divisor (i.e., <code>dividend % divisor</code>).</li>
-     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
-     *     <li>Pushes the result of the modulus operation back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
-     * primarily used to handle basic float32 modulus (remainder) tasks.</p>
-     */
-    public static final int F_MOD = 55;
-    /**
-     * F_INC Opcode: Represents the float32 increment operation for a local variable in the virtual machine.
-     * <p>This opcode is implemented by the {@link FIncCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Retrieves the index of the local variable and the increment value from the instruction parameters.</li>
-     *     <li>Gets the current value of the local variable at the specified index from the local variable store.</li>
-     *     <li>Increments the local variable's value by the specified increment (i.e.,
-     *         <code>localVariables[index] += increment</code>).</li>
-     *     <li>Updates the local variable store with the new incremented value.</li>
-     *     <li>Returns the updated program counter (PC) value, typically incremented by 1, unless control flow changes.</li>
-     * </ol>
-     *
-     * <p>This opcode is particularly useful for optimizing scenarios where a local `float32` variable, such as a counter or loop index, is frequently incremented.</p>
-     */
-    public static final int F_INC = 56;
-
-    /**
-     * F_NEG Opcode: Represents the float32 negation operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link FNegCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top float32 value from the operand stack.</li>
-     *     <li>Performs the negation of the popped value (i.e., <code>-value</code>).</li>
-     *     <li>Pushes the negated result back onto the operand stack for later instructions to use.</li>
-     * </ol>
-     *
-     * <p>This opcode is typically used to negate a float32 value, making it a fundamental operation for float32 arithmetic logic within the virtual machine.</p>
-     */
-    public static final int F_NEG = 57;
-
-    /**
-     * I2L Opcode: Represents the type conversion operation from int32 to long64 in the virtual machine.
-     * <p>This opcode is implemented by the {@link I2LCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top int32 value from the operand stack.</li>
-     *     <li>Convert the int32 value to a long64 value.</li>
-     *     <li>Push the converted long64 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used to widen an int32 value to a long64 type to accommodate larger numeric ranges.</p>
-     */
-    public static final int I2L = 61;
-
-    /**
-     * I2S Opcode: Represents the type conversion operation from int32 to short16 in the virtual machine.
-     * <p>This opcode is implemented by the {@link I2SCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top int32 value from the operand stack.</li>
-     *     <li>Convert the int32 value to a short16 value (this may involve truncation).</li>
-     *     <li>Push the converted short16 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is typically used to narrow an int32 value to a short16 type when a smaller data representation is needed.</p>
-     */
-    public static final int I2S = 62;
-
-    /**
-     * I2B Opcode: Represents the type conversion operation from int32 to byte8 in the virtual machine.
-     * <p>This opcode is implemented by the {@link I2BCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top int32 value from the operand stack.</li>
-     *     <li>Convert the int32 value to a byte8 value (this may involve truncation).</li>
-     *     <li>Push the converted byte8 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is used to narrow an int32 value to a byte8 type, suitable when a smaller numeric type is required.</p>
-     */
-    public static final int I2B = 63;
-
-    /**
-     * I2D Opcode: Represents the type conversion operation from int32 to double64 in the virtual machine.
-     * <p>This opcode is implemented by the {@link I2DCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top int32 value from the operand stack.</li>
-     *     <li>Convert the int32 value to a double64 value.</li>
-     *     <li>Push the converted double64 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is used to widen an int32 value to a double64 type, providing high-precision floating-point calculations.</p>
-     */
-    public static final int I2D = 64;
-
-    /**
-     * I2F Opcode: Represents the type conversion operation from int32 to float32 in the virtual machine.
-     * <p>This opcode is implemented by the {@link I2FCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top int32 value from the operand stack.</li>
-     *     <li>Convert the int32 value to a float32 value.</li>
-     *     <li>Push the converted float32 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is used to convert an int32 value to a float32 type when floating-point arithmetic is required.</p>
-     */
-    public static final int I2F = 65;
-
-    /**
-     * L2I Opcode: Represents the type conversion operation from long64 to int32 in the virtual machine.
-     * <p>This opcode is implemented by the {@link L2ICommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top long64 value from the operand stack.</li>
-     *     <li>Convert the long64 value to an int32 value (this may involve truncation).</li>
-     *     <li>Push the converted int32 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is typically used to narrow a long64 value to an int32 type for further integer operations.</p>
-     */
-    public static final int L2I = 66;
-
-    /**
-     * L2D Opcode: Represents the type conversion operation from long64 to double64 in the virtual machine.
-     * <p>This opcode is implemented by the {@link L2DCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top long64 value from the operand stack.</li>
-     *     <li>Convert the long64 value to a double64 value.</li>
-     *     <li>Push the converted double64 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is used to widen a long64 value to a double64 type for high-precision floating-point computations.</p>
-     */
-    public static final int L2D = 67;
-
-    /**
-     * L2F Opcode: Represents the type conversion operation from long64 to float32 in the virtual machine.
-     * <p>This opcode is implemented by the {@link L2FCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top long64 value from the operand stack.</li>
-     *     <li>Convert the long64 value to a float32 value.</li>
-     *     <li>Push the converted float32 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is used to convert a long64 value to a float32 type, typically for floating-point arithmetic involving long values.</p>
-     */
-    public static final int L2F = 68;
-
-    /**
-     * F2I Opcode: Represents the type conversion operation from float32 to int32 in the virtual machine.
-     * <p>This opcode is implemented by the {@link F2ICommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top float32 value from the operand stack.</li>
-     *     <li>Convert the float32 value to an int32 value (this may involve truncation).</li>
-     *     <li>Push the converted int32 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is used to convert a float32 value to an int32 type for further integer-based operations or comparisons.</p>
-     */
-    public static final int F2I = 69;
-
-    /**
-     * F2L Opcode: Represents the type conversion operation from float32 to long64 in the virtual machine.
-     * <p>This opcode is implemented by the {@link F2LCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top float32 value from the operand stack.</li>
-     *     <li>Convert the float32 value to a long64 value.</li>
-     *     <li>Push the converted long64 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is used to widen a float32 value to a long64 type, which is useful when operations require a larger numeric range.</p>
-     */
-    public static final int F2L = 70;
-
-    /**
-     * F2D Opcode: Represents the type conversion operation from float32 to double64 in the virtual machine.
-     * <p>This opcode is implemented by the {@link F2DCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top float32 value from the operand stack.</li>
-     *     <li>Convert the float32 value to a double64 value.</li>
-     *     <li>Push the converted double64 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is used to promote a float32 value to a double64 type, thereby increasing precision for floating-point computations.</p>
-     */
-    public static final int F2D = 71;
-
-    /**
-     * D2I Opcode: Represents the type conversion operation from double64 to int32 in the virtual machine.
-     * <p>This opcode is implemented by the {@link D2ICommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top double64 value from the operand stack.</li>
-     *     <li>Convert the double64 value to an int32 value (this may involve truncation).</li>
-     *     <li>Push the converted int32 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is used to narrow a double64 value to an int32 type for further integer-based processing.</p>
-     */
-    public static final int D2I = 72;
-
-    /**
-     * D2L Opcode: Represents the type conversion operation from double64 to long64 in the virtual machine.
-     * <p>This opcode is implemented by the {@link D2LCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top double64 value from the operand stack.</li>
-     *     <li>Convert the double64 value to a long64 value (this may involve truncation).</li>
-     *     <li>Push the converted long64 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is used to narrow a double64 value to a long64 type, which can then be used for integer operations.</p>
-     */
-    public static final int D2L = 73;
-
-    /**
-     * D2F Opcode: Represents the type conversion operation from double64 to float32 in the virtual machine.
-     * <p>This opcode is implemented by the {@link D2FCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top double64 value from the operand stack.</li>
-     *     <li>Convert the double64 value to a float32 value.</li>
-     *     <li>Push the converted float32 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is used to narrow a double64 value to a float32 type when lower precision floating-point arithmetic is acceptable.</p>
-     */
-    public static final int D2F = 74;
-
-    /**
-     * S2I Opcode: Represents the type conversion operation from short16 to int32 in the virtual machine.
-     * <p>This opcode is implemented by the {@link S2ICommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top short16 value from the operand stack.</li>
-     *     <li>Convert the short16 value to an int32 value.</li>
-     *     <li>Push the converted int32 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is used to widen a short16 value to an int32 type, facilitating subsequent integer arithmetic or comparison operations.</p>
-     */
-    public static final int S2I = 75;
-
-    /**
-     * B2I Opcode: Represents the type conversion operation from byte8 to int32 in the virtual machine.
-     * <p>This opcode is implemented by the {@link B2ICommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pop the top byte8 value from the operand stack.</li>
-     *     <li>Convert the byte8 value to an int32 value.</li>
-     *     <li>Push the converted int32 value back onto the operand stack for subsequent operations.</li>
-     * </ol>
-     *
-     * <p>This opcode is used to widen a byte8 value to an int32 type to ensure compatibility with integer-based operations.</p>
-     */
-    public static final int B2I = 76;
-
-
-
-    // 2.  Bitwise Operations (81–90)
-    // 2.1 int32 (81-85)
-    /**
-     * I_AND Opcode: Represents the int32 bitwise AND operation in the virtual machine.
+     * I_AND Opcode: Represents the short16 bitwise AND operation in the virtual machine.
      * <p>This opcode is implemented by the {@link IAndCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top two int32 values from the operand stack. These values are treated as 32-bit binary representations.</li>
-     *     <li>Performs the int32 bitwise AND operation on the two popped operands. The operation compares corresponding bits of both operands:
+     *     <li>Pops the top two short16 values from the operand stack. These values are treated as 32-bit binary representations.</li>
+     *     <li>Performs the short16 bitwise AND operation on the two popped operands. The operation compares corresponding bits of both operands:
      *         <ul>
      *             <li>Each bit in the result is set to <code>1</code> only if the corresponding bits in both operands are also <code>1</code>.</li>
      *             <li>If either of the corresponding bits is <code>0</code>, the resulting bit is <code>0</code>.</li>
      *         </ul>
      *     </li>
-     *     <li>Pushes the result of the int32 bitwise AND operation back onto the operand stack for further processing.</li>
+     *     <li>Pushes the result of the short16 bitwise AND operation back onto the operand stack for further processing.</li>
      * </ol>
      *
      * <p>This opcode is essential for low-level bit manipulation tasks.</p>
      */
-    public static final int I_AND = 81;
+    public static final int S_AND = 0x0027;
     /**
-     * I_OR Opcode: Represents the int32 bitwise OR operation in the virtual machine.
+     * I_OR Opcode: Represents the short16 bitwise OR operation in the virtual machine.
      * <p>This opcode is implemented by the {@link IOrCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top two int32 values from the operand stack. These values are treated as 32-bit binary representations.</li>
-     *     <li>Performs the int32 bitwise OR operation on the two popped operands. The operation compares corresponding bits of both operands:
+     *     <li>Pops the top two short16 values from the operand stack. These values are treated as 32-bit binary representations.</li>
+     *     <li>Performs the short16 bitwise OR operation on the two popped operands. The operation compares corresponding bits of both operands:
      *         <ul>
      *             <li>Each bit in the result is set to <code>1</code> if at least one of the corresponding bits in either operand is <code>1</code>.</li>
      *             <li>If both corresponding bits are <code>0</code>, the resulting bit is <code>0</code>.</li>
      *         </ul>
      *     </li>
-     *     <li>Pushes the result of the int32 bitwise OR operation back onto the operand stack for further processing.</li>
+     *     <li>Pushes the result of the short16 bitwise OR operation back onto the operand stack for further processing.</li>
      * </ol>
      *
      * <p>This opcode is essential for low-level bit manipulation tasks.</p>
      */
-    public static final int I_OR = 82;
-
+    public static final int S_OR = 0x0028;
     /**
-     * I_XOR Opcode: Represents the int32 bitwise XOR operation in the virtual machine.
+     * I_XOR Opcode: Represents the short16 bitwise XOR operation in the virtual machine.
      * <p>This opcode is implemented by the {@link IXorCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Pops the top two int32 values from the operand stack. These values are treated as 32-bit binary representations.</li>
-     *     <li>Performs the int32 bitwise XOR (exclusive OR) operation on the two operands:
+     *     <li>Pops the top two short16 values from the operand stack. These values are treated as 32-bit binary representations.</li>
+     *     <li>Performs the short16 bitwise XOR (exclusive OR) operation on the two operands:
      *         <ul>
      *             <li>If the corresponding bits are different, the result is <code>1</code>.</li>
      *             <li>If the corresponding bits are the same, the result is <code>0</code>.</li>
      *         </ul>
      *     </li>
-     *     <li>Pushes the result of the int32 bitwise XOR operation back onto the operand stack for further processing.</li>
+     *     <li>Pushes the result of the short16 bitwise XOR operation back onto the operand stack for further processing.</li>
      * </ol>
      *
      * <p>This opcode is essential for low-level bit manipulation tasks.</p>
      */
-    public static final int I_XOR = 83;
-
-    // 2.2 Long64 (86-90)
-    /**
-     * L_AND Opcode: Represents the long64 bitwise AND operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link LAndCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two long64 values from the operand stack. These values are treated as 32-bit binary representations.</li>
-     *     <li>Performs the long64 bitwise AND operation on the two popped operands. The operation compares corresponding bits of both operands:
-     *         <ul>
-     *             <li>Each bit in the result is set to <code>1</code> only if the corresponding bits in both operands are also <code>1</code>.</li>
-     *             <li>If either of the corresponding bits is <code>0</code>, the resulting bit is <code>0</code>.</li>
-     *         </ul>
-     *     </li>
-     *     <li>Pushes the result of the long64 bitwise AND operation back onto the operand stack for further processing.</li>
-     * </ol>
-     *
-     * <p>This opcode is essential for low-level bit manipulation tasks.</p>
-     */
-    public static final int L_AND = 86;
-    /**
-     * L_OR Opcode: Represents the long64 bitwise OR operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link LOrCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two long64 values from the operand stack. These values are treated as 32-bit binary representations.</li>
-     *     <li>Performs the long64 bitwise OR operation on the two popped operands. The operation compares corresponding bits of both operands:
-     *         <ul>
-     *             <li>Each bit in the result is set to <code>1</code> if at least one of the corresponding bits in either operand is <code>1</code>.</li>
-     *             <li>If both corresponding bits are <code>0</code>, the resulting bit is <code>0</code>.</li>
-     *         </ul>
-     *     </li>
-     *     <li>Pushes the result of the long64 bitwise OR operation back onto the operand stack for further processing.</li>
-     * </ol>
-     *
-     * <p>This opcode is essential for low-level bit manipulation tasks.</p>
-     */
-    public static final int L_OR = 87;
-
-    /**
-     * L_XOR Opcode: Represents the long64 bitwise XOR operation in the virtual machine.
-     * <p>This opcode is implemented by the {@link LXorCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Pops the top two long64 values from the operand stack. These values are treated as 32-bit binary representations.</li>
-     *     <li>Performs the long64 bitwise XOR (exclusive OR) operation on the two operands:
-     *         <ul>
-     *             <li>If the corresponding bits are different, the result is <code>1</code>.</li>
-     *             <li>If the corresponding bits are the same, the result is <code>0</code>.</li>
-     *         </ul>
-     *     </li>
-     *     <li>Pushes the result of the long64 bitwise XOR operation back onto the operand stack for further processing.</li>
-     * </ol>
-     *
-     * <p>This opcode is essential for low-level bit manipulation tasks.</p>
-     */
-    public static final int L_XOR = 88;
-
-
-    // 3. Control Flow Operations (91–110)
-    /**
-     * JUMP Opcode: Represents an unconditional jump to a target instruction address.
-     * <p>This opcode is implemented by the {@link JumpCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Parses the target instruction address from the instruction parameters.</li>
-     *     <li>Validates the target address to ensure it is a non-negative int32.</li>
-     *     <li>If the target address is valid (greater than or equal to 0), updates the program counter (PC) to the specified target address,
-     *         effectively skipping all intermediate instructions.</li>
-     *     <li>If the target address is invalid (less than 0), logs an error message and halts execution by returning an invalid value (typically -1).</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used for:</p>
-     * <ul>
-     *     <li>Control flow management in virtual machine execution.</li>
-     * </ul>
-     */
-    public static final int JUMP = 91;
-    /**
-     * IC_E Opcode: Represents a conditional jump based on int32 equality.
-     * <p>This opcode is implemented by the {@link ICECommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Parses the target instruction address from the instruction parameters.</li>
-     *     <li>Pops two int32 values from the operand stack.</li>
-     *     <li>Compares the two int32s for equality.</li>
-     *     <li>If the int32s are equal, updates the program counter (PC) to the specified target address,
-     *         effectively jumping to the target instruction.</li>
-     *     <li>If the int32s are not equal, increments the program counter to proceed with the next sequential instruction.</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used for:</p>
-     * <ul>
-     *     <li>Conditional branching in virtual machine execution based on int32 comparison.</li>
-     *     <li>Implementing control flow structures such as if-statements and loops.</li>
-     * </ul>
-     */
-    public static final int IC_E = 92;
-    /**
-     * IC_NE Opcode: Represents a conditional jump based on int32 inequality.
-     * <p>This opcode is implemented by the {@link ICNECommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Parses the target instruction address from the instruction parameters.</li>
-     *     <li>Pops two int32 values from the operand stack.</li>
-     *     <li>Compares the two int32s for inequality.</li>
-     *     <li>If the int32s are not equal, updates the program counter (PC) to the specified target address,
-     *         effectively jumping to the target instruction.</li>
-     *     <li>If the int32s are equal, increments the program counter to proceed with the next sequential instruction.</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used for:</p>
-     * <ul>
-     *     <li>Conditional branching in virtual machine execution based on int32 comparison.</li>
-     *     <li>Implementing control flow structures such as conditional loops and if-else statements.</li>
-     * </ul>
-     */
-    public static final int IC_NE = 93;
-    /**
-     * IC_G Opcode: Represents a conditional jump based on int32 comparison (greater than).
-     * <p>This opcode is implemented by the {@link ICGCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Parses the target instruction address from the instruction parameters.</li>
-     *     <li>Pops two int32 values from the operand stack.</li>
-     *     <li>Compares the first int32 with the second to determine if it is greater.</li>
-     *     <li>If the first int32 is greater than the second, updates the program counter (PC) to the specified target address,
-     *         effectively jumping to the target instruction.</li>
-     *     <li>If the first int32 is not greater than the second, increments the program counter to proceed with the next sequential instruction.</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used for:</p>
-     * <ul>
-     *     <li>Conditional branching in virtual machine execution based on int32 comparison.</li>
-     *     <li>Implementing control flow structures such as greater-than conditions in loops and conditional statements.</li>
-     * </ul>
-     */
-    public static final int IC_G = 94;
-    /**
-     * IC_GE Opcode: Represents a conditional jump based on int32 comparison (greater than or equal to).
-     * <p>This opcode is implemented by the {@link ICGECommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Parses the target instruction address from the instruction parameters.</li>
-     *     <li>Pops two int32 values from the operand stack.</li>
-     *     <li>Compares the first int32 with the second to determine if it is greater than or equal to the second int32.</li>
-     *     <li>If the first int32 is greater than or equal to the second, updates the program counter (PC) to the specified target address,
-     *         effectively jumping to the target instruction.</li>
-     *     <li>If the first int32 is less than the second, increments the program counter to proceed with the next sequential instruction.</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used for:</p>
-     * <ul>
-     *     <li>Conditional branching in virtual machine execution based on int32 comparison.</li>
-     *     <li>Implementing control flow structures such as loops, conditional statements, and range checks.</li>
-     * </ul>
-     */
-    public static final int IC_GE = 95;
-    /**
-     * IC_L Opcode: Represents a conditional jump based on int32 comparison (less than).
-     * <p>This opcode is implemented by the {@link ICLCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Parses the target instruction address from the instruction parameters.</li>
-     *     <li>Pops two int32 values from the operand stack.</li>
-     *     <li>Compares the first int32 with the second to determine if it is less than the second int32.</li>
-     *     <li>If the first int32 is less than the second, updates the program counter (PC) to the specified target address,
-     *         effectively jumping to the target instruction.</li>
-     *     <li>If the first int32 is greater than or equal to the second, increments the program counter to proceed with the next sequential instruction.</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used for:</p>
-     * <ul>
-     *     <li>Conditional branching in virtual machine execution based on int32 comparison.</li>
-     *     <li>Implementing control flow structures such as loops, conditional statements, and range validations.</li>
-     * </ul>
-     */
-    public static final int IC_L = 96;
-    /**
-     * IC_LE Opcode: Represents a conditional jump based on int32 comparison (less than or equal).
-     * <p>This opcode is implemented by the {@link ICLECommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Parses the target instruction address from the instruction parameters.</li>
-     *     <li>Pops two int32 values from the operand stack.</li>
-     *     <li>Compares the first int32 with the second to determine if it is less than or equal to the second int32.</li>
-     *     <li>If the first int32 is less than or equal to the second, updates the program counter (PC) to the specified target address,
-     *         effectively jumping to the target instruction.</li>
-     *     <li>If the first int32 is greater than the second, increments the program counter to proceed with the next sequential instruction.</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used for:</p>
-     * <ul>
-     *     <li>Conditional branching in virtual machine execution based on int32 comparison.</li>
-     *     <li>Implementing control flow structures such as loops, conditional statements, and boundary checks.</li>
-     * </ul>
-     */
-    public static final int IC_LE = 97;
-
-    // 4.  Stack Operations (111–150)
-    // 4.1 PUSH (111-120)
-    /**
-     * I_PUSH Opcode: Represents a stack operation that pushes an int32 value onto the operand stack.
-     * <p>This opcode is implemented by the {@link IPushCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Parses the int32 value from the instruction parameters.</li>
-     *     <li>Pushes the parsed int32 value onto the operand stack.</li>
-     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used for:</p>
-     * <ul>
-     *     <li>Loading constant values into the operand stack for later operations.</li>
-     *     <li>Preparing operands for arithmetic, logical, or comparison instructions.</li>
-     *     <li>Facilitating method calls or control flow by managing stack-based data.</li>
-     * </ul>
-     */
-    public static final int I_PUSH = 111;
-    /**
-     * L_PUSH Opcode: Represents a stack operation that pushes a long64 value onto the operand stack.
-     * <p>This opcode is implemented by the {@link LPushCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Parses the long64 value from the instruction parameters.</li>
-     *     <li>Pushes the parsed long64 value onto the operand stack.</li>
-     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used for:</p>
-     * <ul>
-     *     <li>Loading constant values into the operand stack for later operations.</li>
-     *     <li>Preparing operands for arithmetic, logical, or comparison instructions.</li>
-     *     <li>Facilitating method calls or control flow by managing stack-based data.</li>
-     * </ul>
-     */
-    public static final int L_PUSH = 112;
+    public static final int S_XOR = 0x0029;
     /**
      * S_PUSH Opcode: Represents a stack operation that pushes a short16 value onto the operand stack.
      * <p>This opcode is implemented by the {@link SPushCommand} class, which defines its specific execution logic.</p>
@@ -1305,127 +572,380 @@ public class VMOpCode {
      *     <li>Facilitating method calls or control flow by managing stack-based data.</li>
      * </ul>
      */
-    public static final int S_PUSH = 113;
+    public static final int S_PUSH = 0x002A;
     /**
-     * I_PUSH Opcode: Represents a stack operation that pushes a byte8 value onto the operand stack.
-     * <p>This opcode is implemented by the {@link BPushCommand} class, which defines its specific execution logic.</p>
+     * S_LOAD Opcode: Represents a load operation that retrieves a short16 value from the local variable store and pushes it onto the operand stack.
+     * <p>This opcode is implemented by the {@link SLoadCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Parses the byte8 value from the instruction parameters.</li>
-     *     <li>Pushes the parsed byte8 value onto the operand stack.</li>
+     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
+     *     <li>Retrieves the corresponding value from the local variable store of the current method frame.</li>
+     *     <li>Pushes the retrieved value onto the operand stack for subsequent operations.</li>
      *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
      * </ol>
      *
      * <p>This opcode is commonly used for:</p>
      * <ul>
-     *     <li>Loading constant values into the operand stack for later operations.</li>
-     *     <li>Preparing operands for arithmetic, logical, or comparison instructions.</li>
-     *     <li>Facilitating method calls or control flow by managing stack-based data.</li>
+     *     <li>Loading local variables onto the operand stack for further operations or computations.</li>
+     *     <li>Retrieving stored values that are needed for subsequent instructions, such as arithmetic or logic operations.</li>
+     *     <li>Preserving the necessary method-local state by pushing relevant values from the local variable store to the operand stack.</li>
      * </ul>
      */
-    public static final int B_PUSH = 114;
+    public static final int S_LOAD = 0x002B;
     /**
-     * I_PUSH Opcode: Represents a stack operation that pushes a double64 value onto the operand stack.
-     * <p>This opcode is implemented by the {@link DPushCommand} class, which defines its specific execution logic.</p>
+     * S_STORE Opcode: Represents a store operation that stores a short16 value from the operand stack into the local variable store.
+     * <p>This opcode is implemented by the {@link SStoreCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Parses the double64 value from the instruction parameters.</li>
-     *     <li>Pushes the parsed double64 value onto the operand stack.</li>
+     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
+     *     <li>Pops a short16 value from the operand stack.</li>
+     *     <li>Stores the value into the local variable store at the specified index of the current method frame.</li>
      *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
      * </ol>
      *
      * <p>This opcode is commonly used for:</p>
      * <ul>
-     *     <li>Loading constant values into the operand stack for later operations.</li>
-     *     <li>Preparing operands for arithmetic, logical, or comparison instructions.</li>
-     *     <li>Facilitating method calls or control flow by managing stack-based data.</li>
+     *     <li>Storing short16 values resulting from calculations or conversions.</li>
+     *     <li>Temporarily saving data in local variables for later instructions.</li>
+     *     <li>Supporting typed local variable storage for short values.</li>
      * </ul>
      */
-    public static final int D_PUSH = 115;
+    public static final int S_STORE = 0x002C;
     /**
-     * F_PUSH Opcode: Represents a stack operation that pushes a float32 value onto the operand stack.
-     * <p>This opcode is implemented by the {@link FPushCommand} class, which defines its specific execution logic.</p>
+     * I_CE Opcode: Represents a conditional jump based on short16 equality.
+     * <p>This opcode is implemented by the {@link ICECommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Parses the float32 value from the instruction parameters.</li>
-     *     <li>Pushes the parsed float32 value onto the operand stack.</li>
-     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two short16 values from the operand stack.</li>
+     *     <li>Compares the two short16 for equality.</li>
+     *     <li>If the short16 are equal, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the short16 are not equal, increments the program counter to proceed with the next sequential instruction.</li>
      * </ol>
      *
      * <p>This opcode is commonly used for:</p>
      * <ul>
-     *     <li>Loading constant values into the operand stack for later operations.</li>
-     *     <li>Preparing operands for arithmetic, logical, or comparison instructions.</li>
-     *     <li>Facilitating method calls or control flow by managing stack-based data.</li>
+     *     <li>Conditional branching in virtual machine execution based on short16 comparison.</li>
+     *     <li>Implementing control flow structures such as if-statements and loops.</li>
      * </ul>
      */
-    public static final int F_PUSH = 116;
+    public static final int S_CE = 0x002D;
     /**
-     * I_POP Opcode: Represents a stack operation that removes the top element from the operand stack.
-     * <p>This opcode is implemented by the {@link PopCommand} class, which defines its specific execution logic.</p>
+     * I_CNE Opcode: Represents a conditional jump based on short16 inequality.
+     * <p>This opcode is implemented by the {@link ICNECommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Removes (pops) the top element from the operand stack.</li>
-     *     <li>Discards the popped value, as it is not stored or used further.</li>
-     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two short16 values from the operand stack.</li>
+     *     <li>Compares the two short16 for inequality.</li>
+     *     <li>If the short16 are not equal, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the short16 are equal, increments the program counter to proceed with the next sequential instruction.</li>
      * </ol>
      *
      * <p>This opcode is commonly used for:</p>
      * <ul>
-     *     <li>Clearing temporary or unnecessary data from the operand stack.</li>
-     *     <li>Managing stack cleanup after operations that leave excess data.</li>
-     *     <li>Ensuring stack balance during function calls or control flow transitions.</li>
+     *     <li>Conditional branching in virtual machine execution based on short16 comparison.</li>
+     *     <li>Implementing control flow structures such as conditional loops and if-else statements.</li>
      * </ul>
      */
-    // 4.2 POP (121-125)
-    public static final int POP = 121;
+    public static final int S_CNE = 0x002E;
     /**
-     * DUP Opcode: Represents a stack operation that duplicates the top element of the operand stack.
-     * <p>This opcode is implemented by the {@link DupCommand} class, which defines its specific execution logic.</p>
+     * I_CG Opcode: Represents a conditional jump based on short16 comparison (greater than).
+     * <p>This opcode is implemented by the {@link ICGCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Retrieves the top element from the operand stack.</li>
-     *     <li>Duplicates the top value and pushes it back onto the stack.</li>
-     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two short16 values from the operand stack.</li>
+     *     <li>Compares the first short16 with the second to determine if it is greater.</li>
+     *     <li>If the first short16 is greater than the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first short16 is not greater than the second, increments the program counter to proceed with the next sequential instruction.</li>
      * </ol>
      *
      * <p>This opcode is commonly used for:</p>
      * <ul>
-     *     <li>Preserving the top element of the operand stack for later use in later operations.</li>
-     *     <li>Duplicating values that are needed multiple times in the execution flow.</li>
-     *     <li>Managing stack balance when performing operations that require repeated access to the same data.</li>
+     *     <li>Conditional branching in virtual machine execution based on short16 comparison.</li>
+     *     <li>Implementing control flow structures such as greater-than conditions in loops and conditional statements.</li>
      * </ul>
      */
-    // 4.3 DUP (126-130)
-    public static final int DUP = 126;
+    public static final int S_CG = 0x002F;
     /**
-     * SWAP Opcode: Represents a stack operation that swaps the top two values of the operand stack.
-     * <p>This opcode is implemented by the {@link SwapCommand} class, which defines its specific execution logic.</p>
+     * I_CGE Opcode: Represents a conditional jump based on short16 comparison (greater than or equal to).
+     * <p>This opcode is implemented by the {@link ICGECommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Ensures that there are at least two elements on the operand stack.</li>
-     *     <li>Pops the two topmost values from the stack.</li>
-     *     <li>Pushes the two values back onto the stack in reversed order.</li>
-     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two short16 values from the operand stack.</li>
+     *     <li>Compares the first short16 with the second to determine if it is greater than or equal to the second short16.</li>
+     *     <li>If the first short16 is greater than or equal to the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first short16 is less than the second, increments the program counter to proceed with the next sequential instruction.</li>
      * </ol>
      *
      * <p>This opcode is commonly used for:</p>
      * <ul>
-     *     <li>Reversing the order of the top two elements on the stack, which may be required in certain algorithms or operations.</li>
-     *     <li>Handling data rearrangements that require immediate swapping of operands during execution.</li>
-     *     <li>Ensuring proper operand placement for later instructions that depend on the order of stack elements.</li>
+     *     <li>Conditional branching in virtual machine execution based on short16 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and range checks.</li>
      * </ul>
      */
-    // 4.4 SWAP (131-135)
-    public static final int SWAP = 131;
+    public static final int S_CGE = 0x0030;
+    /**
+     * I_CL Opcode: Represents a conditional jump based on short16 comparison (less than).
+     * <p>This opcode is implemented by the {@link ICLCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two short16 values from the operand stack.</li>
+     *     <li>Compares the first short16 with the second to determine if it is less than the second short16.</li>
+     *     <li>If the first short16 is less than the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first short16 is greater than or equal to the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on short16 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and range validations.</li>
+     * </ul>
+     */
+    public static final int S_CL = 0x0031;
+    /**
+     * S_CLE Opcode: Represents a conditional jump based on short16 comparison (less than or equal).
+     * <p>This opcode is implemented by the {@link ICLECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two short16 values from the operand stack.</li>
+     *     <li>Compares the first short16 with the second to determine if it is less than or equal to the second short16.</li>
+     *     <li>If the first short16 is less than or equal to the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first short16 is greater than the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on short16 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and boundary checks.</li>
+     * </ul>
+     */
+    public static final int S_CLE = 0x0032;
+    // endregion
 
-    // 5. Memory Operations (151–)
+    // region Int32 (0x0040-0x005F)
+    /**
+     * I_ADD Opcode: Represents the int32 addition operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link IAddCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two int32 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
+     *     <li>Performs the addition operation on these two int32s.</li>
+     *     <li>Pushes the result of the addition back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic int32 addition tasks.</p>
+     */
+    public static final int I_ADD = 0x0040;
+    /**
+     * I_SUB Opcode: Represents the int32 subtraction operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link ISubCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two int32 values from the operand stack (the first value popped is the subtrahend, and the second value popped is the minuend).</li>
+     *     <li>Performs the subtraction operation by subtracting the subtrahend from the minuend (i.e., <code>minuend - subtrahend</code>).</li>
+     *     <li>Pushes the result of the subtraction back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic int32 subtraction tasks.</p>
+     */
+    public static final int I_SUB = 0x0041;
+    /**
+     * I_MUL Opcode: Represents the int32 multiplication operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link IMulCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two int32 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
+     *     <li>Performs the multiplication operation on these two int32s (i.e., <code>firstOperand * secondOperand</code>).</li>
+     *     <li>Pushes the result of the multiplication back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic int32 multiplication tasks.</p>
+     */
+    public static final int I_MUL = 0x0042;
+    /**
+     * I_DIV Opcode: Represents the int32 division operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link IDivCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two int32 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
+     *     <li>Performs the division operation by dividing the dividend by the divisor (i.e., <code>dividend / divisor</code>).</li>
+     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
+     *     <li>Pushes the result of the division back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic int32 division tasks.</p>
+     */
+    public static final int I_DIV = 0x0043;
+    /**
+     * I_MOD Opcode: Represents the int32 modulus (remainder) operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link IModCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two int32 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
+     *     <li>Performs the modulus operation by calculating the remainder of the division of the dividend by the divisor (i.e., <code>dividend % divisor</code>).</li>
+     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
+     *     <li>Pushes the result of the modulus operation back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic int32 modulus (remainder)  tasks.</p>
+     */
+    public static final int I_MOD = 0x0044;
+    /**
+     * I_NEG Opcode: Represents the int32 negation operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link INegCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top int32 value from the operand stack.</li>
+     *     <li>Performs the negation of the popped value (i.e., <code>-value</code>).</li>
+     *     <li>Pushes the negated result back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is typically used to negate an int32 value, making it a fundamental operation for arithmetic logic within the virtual machine.</p>
+     */
+    public static final int I_NEG = 0x0045;
+    /**
+     * I_INC Opcode: Represents the int32 increment operation for a local variable in the virtual machine.
+     * <p>This opcode is implemented by the {@link IIncCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Retrieves the index of the local variable and the increment value from the instruction parameters.</li>
+     *     <li>Gets the current value of the local variable at the specified index from the local variable store.</li>
+     *     <li>Increments the local variable's value by the specified increment (i.e.,
+     *         <code>localVariables[index] += increment</code>).</li>
+     *     <li>Updates the local variable store with the new incremented value.</li>
+     *     <li>Returns the updated program counter (PC) value, typically incremented by 1, unless control flow changes.</li>
+     * </ol>
+     *
+     * <p>This opcode is particularly useful for optimizing scenarios where a local variable, such as a counter or loop index, is frequently incremented.</p>
+     */
+    public static final int I_INC = 0x0046;
+    /**
+     * I_AND Opcode: Represents the int32 bitwise AND operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link IAndCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two int32 values from the operand stack. These values are treated as 32-bit binary representations.</li>
+     *     <li>Performs the int32 bitwise AND operation on the two popped operands. The operation compares corresponding bits of both operands:
+     *         <ul>
+     *             <li>Each bit in the result is set to <code>1</code> only if the corresponding bits in both operands are also <code>1</code>.</li>
+     *             <li>If either of the corresponding bits is <code>0</code>, the resulting bit is <code>0</code>.</li>
+     *         </ul>
+     *     </li>
+     *     <li>Pushes the result of the int32 bitwise AND operation back onto the operand stack for further processing.</li>
+     * </ol>
+     *
+     * <p>This opcode is essential for low-level bit manipulation tasks.</p>
+     */
+    public static final int I_AND = 0x0047;
+    /**
+     * I_OR Opcode: Represents the int32 bitwise OR operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link IOrCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two int32 values from the operand stack. These values are treated as 32-bit binary representations.</li>
+     *     <li>Performs the int32 bitwise OR operation on the two popped operands. The operation compares corresponding bits of both operands:
+     *         <ul>
+     *             <li>Each bit in the result is set to <code>1</code> if at least one of the corresponding bits in either operand is <code>1</code>.</li>
+     *             <li>If both corresponding bits are <code>0</code>, the resulting bit is <code>0</code>.</li>
+     *         </ul>
+     *     </li>
+     *     <li>Pushes the result of the int32 bitwise OR operation back onto the operand stack for further processing.</li>
+     * </ol>
+     *
+     * <p>This opcode is essential for low-level bit manipulation tasks.</p>
+     */
+    public static final int I_OR = 0x0048;
+    /**
+     * I_XOR Opcode: Represents the int32 bitwise XOR operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link IXorCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two int32 values from the operand stack. These values are treated as 32-bit binary representations.</li>
+     *     <li>Performs the int32 bitwise XOR (exclusive OR) operation on the two operands:
+     *         <ul>
+     *             <li>If the corresponding bits are different, the result is <code>1</code>.</li>
+     *             <li>If the corresponding bits are the same, the result is <code>0</code>.</li>
+     *         </ul>
+     *     </li>
+     *     <li>Pushes the result of the int32 bitwise XOR operation back onto the operand stack for further processing.</li>
+     * </ol>
+     *
+     * <p>This opcode is essential for low-level bit manipulation tasks.</p>
+     */
+    public static final int I_XOR = 0x0049;
+    /**
+     * I_PUSH Opcode: Represents a stack operation that pushes an int32 value onto the operand stack.
+     * <p>This opcode is implemented by the {@link IPushCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the int32 value from the instruction parameters.</li>
+     *     <li>Pushes the parsed int32 value onto the operand stack.</li>
+     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Loading constant values into the operand stack for later operations.</li>
+     *     <li>Preparing operands for arithmetic, logical, or comparison instructions.</li>
+     *     <li>Facilitating method calls or control flow by managing stack-based data.</li>
+     * </ul>
+     */
+    public static final int I_PUSH = 0x004A;
+    /**
+     * I_LOAD Opcode: Represents a load operation that retrieves an int32 value from the local variable store and pushes it onto the operand stack.
+     * <p>This opcode is implemented by the {@link ILoadCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
+     *     <li>Retrieves the corresponding value from the local variable store of the current method frame.</li>
+     *     <li>Pushes the retrieved value onto the operand stack for subsequent operations.</li>
+     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Loading local variables onto the operand stack for further operations or computations.</li>
+     *     <li>Retrieving stored values that are needed for subsequent instructions, such as arithmetic or logic operations.</li>
+     *     <li>Preserving the necessary method-local state by pushing relevant values from the local variable store to the operand stack.</li>
+     * </ul>
+     */
+    public static final int I_LOAD = 0x004B;
     /**
      * I_STORE Opcode: Represents a store operation that saves an int32 value from the operand stack into the local variable store.
      *
@@ -1446,138 +966,320 @@ public class VMOpCode {
      *     <li>Transferring values from the operand stack to the method-local scope.</li>
      * </ul>
      */
-    public static final int I_STORE = 151;
-
-
+    public static final int I_STORE = 0x004C;
     /**
-     * L_STORE Opcode: Represents a store operation that stores a long64 value from the operand stack into the local variable store.
-     * <p>This opcode is implemented by the {@link LStoreCommand} class, which defines its specific execution logic.</p>
+     * I_CE Opcode: Represents a conditional jump based on int32 equality.
+     * <p>This opcode is implemented by the {@link ICECommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
-     *     <li>Pops a long64 value from the operand stack.</li>
-     *     <li>Stores the value into the local variable store at the specified index of the current method frame.</li>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two int32 values from the operand stack.</li>
+     *     <li>Compares the two int32s for equality.</li>
+     *     <li>If the int32s are equal, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the int32s are not equal, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on int32 comparison.</li>
+     *     <li>Implementing control flow structures such as if-statements and loops.</li>
+     * </ul>
+     */
+    public static final int I_CE = 0x004D;
+    /**
+     * I_CNE Opcode: Represents a conditional jump based on int32 inequality.
+     * <p>This opcode is implemented by the {@link ICNECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two int32 values from the operand stack.</li>
+     *     <li>Compares the two int32s for inequality.</li>
+     *     <li>If the int32s are not equal, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the int32s are equal, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on int32 comparison.</li>
+     *     <li>Implementing control flow structures such as conditional loops and if-else statements.</li>
+     * </ul>
+     */
+    public static final int I_CNE = 0x004E;
+    /**
+     * I_CG Opcode: Represents a conditional jump based on int32 comparison (greater than).
+     * <p>This opcode is implemented by the {@link ICGCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two int32 values from the operand stack.</li>
+     *     <li>Compares the first int32 with the second to determine if it is greater.</li>
+     *     <li>If the first int32 is greater than the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first int32 is not greater than the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on int32 comparison.</li>
+     *     <li>Implementing control flow structures such as greater-than conditions in loops and conditional statements.</li>
+     * </ul>
+     */
+    public static final int I_CG = 0x004F;
+    /**
+     * I_CGE Opcode: Represents a conditional jump based on int32 comparison (greater than or equal to).
+     * <p>This opcode is implemented by the {@link ICGECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two int32 values from the operand stack.</li>
+     *     <li>Compares the first int32 with the second to determine if it is greater than or equal to the second int32.</li>
+     *     <li>If the first int32 is greater than or equal to the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first int32 is less than the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on int32 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and range checks.</li>
+     * </ul>
+     */
+    public static final int I_CGE = 0x0050;
+    /**
+     * I_CL Opcode: Represents a conditional jump based on int32 comparison (less than).
+     * <p>This opcode is implemented by the {@link ICLCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two int32 values from the operand stack.</li>
+     *     <li>Compares the first int32 with the second to determine if it is less than the second int32.</li>
+     *     <li>If the first int32 is less than the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first int32 is greater than or equal to the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on int32 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and range validations.</li>
+     * </ul>
+     */
+    public static final int I_CL = 0x0051;
+    /**
+     * I_CLE Opcode: Represents a conditional jump based on int32 comparison (less than or equal).
+     * <p>This opcode is implemented by the {@link ICLECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two int32 values from the operand stack.</li>
+     *     <li>Compares the first int32 with the second to determine if it is less than or equal to the second int32.</li>
+     *     <li>If the first int32 is less than or equal to the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first int32 is greater than the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on int32 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and boundary checks.</li>
+     * </ul>
+     */
+    public static final int I_CLE = 0x0052;
+    // endregion
+
+    // region Long64 (0x0060-0x007F)
+    /**
+     * L_ADD Opcode: Represents the long64 addition operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link LAddCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two long64 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
+     *     <li>Performs the addition operation on these two long64.</li>
+     *     <li>Pushes the result of the addition back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic long64 addition tasks.</p>
+     */
+    public static final int L_ADD = 0x0060;
+    /**
+     * L_SUB Opcode: Represents the long64 subtraction operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link LSubCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two long64 values from the operand stack (the first value popped is the subtrahend, and the second value popped is the minuend).</li>
+     *     <li>Performs the subtraction operation by subtracting the subtrahend from the minuend (i.e., <code>minuend - subtrahend</code>).</li>
+     *     <li>Pushes the result of the subtraction back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic long64 subtraction tasks.</p>
+     */
+    public static final int L_SUB = 0x0061;
+    /**
+     * L_MUL Opcode: Represents the long64 multiplication operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link LMulCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two long64 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
+     *     <li>Performs the multiplication operation on these two long64 (i.e., <code>firstOperand * secondOperand</code>).</li>
+     *     <li>Pushes the result of the multiplication back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic long64 multiplication tasks.</p>
+     */
+    public static final int L_MUL = 0x0062;
+    /**
+     * L_DIV Opcode: Represents the long64 division operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link LDivCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two long64 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
+     *     <li>Performs the division operation by dividing the dividend by the divisor (i.e., <code>dividend / divisor</code>).</li>
+     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
+     *     <li>Pushes the result of the division back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic long64 division tasks.</p>
+     */
+    public static final int L_DIV = 0x0063;
+    /**
+     * L_MOD Opcode: Represents the long64 modulus (remainder) operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link LModCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two long64 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
+     *     <li>Performs the modulus operation by calculating the remainder of the division of the dividend by the divisor (i.e., <code>dividend % divisor</code>).</li>
+     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
+     *     <li>Pushes the result of the modulus operation back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic long64 modulus (remainder) tasks.</p>
+     */
+    public static final int L_MOD = 0x0064;
+    /**
+     * L_NEG Opcode: Represents the long64 negation operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link LNegCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top long64 value from the operand stack.</li>
+     *     <li>Performs the negation of the popped value (i.e., <code>-value</code>).</li>
+     *     <li>Pushes the negated result back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is typically used to negate a long64 value, making it a fundamental operation for arithmetic logic within the virtual machine.</p>
+     */
+    public static final int L_NEG = 0x0065;
+    /**
+     * L_INC Opcode: Represents the long64 increment operation for a local variable in the virtual machine.
+     * <p>This opcode is implemented by the {@link LIncCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Retrieves the index of the local variable and the increment value from the instruction parameters.</li>
+     *     <li>Gets the current value of the local variable at the specified index from the local variable store.</li>
+     *     <li>Increments the local variable's value by the specified increment (i.e.,
+     *         <code>localVariables[index] += increment</code>).</li>
+     *     <li>Updates the local variable store with the new incremented value.</li>
+     *     <li>Returns the updated program counter (PC) value, typically incremented by 1, unless control flow changes.</li>
+     * </ol>
+     *
+     * <p>This opcode is particularly useful for optimizing scenarios where a local `long64` variable, such as a counter or loop index, is frequently incremented.</p>
+     */
+    public static final int L_INC = 0x0066;
+    /**
+     * L_AND Opcode: Represents the long64 bitwise AND operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link LAndCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two long64 values from the operand stack. These values are treated as 64-bit binary representations.</li>
+     *     <li>Performs the long64 bitwise AND operation on the two popped operands. The operation compares corresponding bits of both operands:
+     *         <ul>
+     *             <li>Each bit in the result is set to <code>1</code> only if the corresponding bits in both operands are also <code>1</code>.</li>
+     *             <li>If either of the corresponding bits is <code>0</code>, the resulting bit is <code>0</code>.</li>
+     *         </ul>
+     *     </li>
+     *     <li>Pushes the result of the long64 bitwise AND operation back onto the operand stack for further processing.</li>
+     * </ol>
+     *
+     * <p>This opcode is essential for low-level bit manipulation tasks.</p>
+     */
+    public static final int L_AND = 0x0067;
+    /**
+     * L_OR Opcode: Represents the long64 bitwise OR operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link LOrCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two long64 values from the operand stack. These values are treated as 64-bit binary representations.</li>
+     *     <li>Performs the long64 bitwise OR operation on the two popped operands. The operation compares corresponding bits of both operands:
+     *         <ul>
+     *             <li>Each bit in the result is set to <code>1</code> if at least one of the corresponding bits in either operand is <code>1</code>.</li>
+     *             <li>If both corresponding bits are <code>0</code>, the resulting bit is <code>0</code>.</li>
+     *         </ul>
+     *     </li>
+     *     <li>Pushes the result of the long64 bitwise OR operation back onto the operand stack for further processing.</li>
+     * </ol>
+     *
+     * <p>This opcode is essential for low-level bit manipulation tasks.</p>
+     */
+    public static final int L_OR = 0x0068;
+    /**
+     * L_XOR Opcode: Represents the long64 bitwise XOR operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link LXorCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two long64 values from the operand stack. These values are treated as 64-bit binary representations.</li>
+     *     <li>Performs the long64 bitwise XOR (exclusive OR) operation on the two operands:
+     *         <ul>
+     *             <li>If the corresponding bits are different, the result is <code>1</code>.</li>
+     *             <li>If the corresponding bits are the same, the result is <code>0</code>.</li>
+     *         </ul>
+     *     </li>
+     *     <li>Pushes the result of the long64 bitwise XOR operation back onto the operand stack for further processing.</li>
+     * </ol>
+     *
+     * <p>This opcode is essential for low-level bit manipulation tasks.</p>
+     */
+    public static final int L_XOR = 0x0069;
+    /**
+     * L_PUSH Opcode: Represents a stack operation that pushes a long64 value onto the operand stack.
+     * <p>This opcode is implemented by the {@link LPushCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the long64 value from the instruction parameters.</li>
+     *     <li>Pushes the parsed long64 value onto the operand stack.</li>
      *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
      * </ol>
      *
      * <p>This opcode is commonly used for:</p>
      * <ul>
-     *     <li>Storing computed long64 values into local variables for reuse.</li>
-     *     <li>Preserving long-type data across multiple instructions or calls.</li>
-     *     <li>Moving data from the operand stack to a persistent method-local context.</li>
+     *     <li>Loading constant values into the operand stack for later operations.</li>
+     *     <li>Preparing operands for arithmetic, logical, or comparison instructions.</li>
+     *     <li>Facilitating method calls or control flow by managing stack-based data.</li>
      * </ul>
      */
-    public static final int L_STORE = 152;
-
-
-    /**
-     * S_STORE Opcode: Represents a store operation that stores a short16 value from the operand stack into the local variable store.
-     * <p>This opcode is implemented by the {@link SStoreCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
-     *     <li>Pops a short16 value from the operand stack.</li>
-     *     <li>Stores the value into the local variable store at the specified index of the current method frame.</li>
-     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used for:</p>
-     * <ul>
-     *     <li>Storing short16 values resulting from calculations or conversions.</li>
-     *     <li>Temporarily saving data in local variables for later instructions.</li>
-     *     <li>Supporting typed local variable storage for short values.</li>
-     * </ul>
-     */
-    public static final int S_STORE = 153;
-
-
-    /**
-     * B_STORE Opcode: Represents a store operation that stores a byte8 value from the operand stack into the local variable store.
-     * <p>This opcode is implemented by the {@link BStoreCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
-     *     <li>Pops a byte8 value from the operand stack.</li>
-     *     <li>Stores the value into the local variable store at the specified index of the current method frame.</li>
-     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used for:</p>
-     * <ul>
-     *     <li>Saving byte8 results or constants into method-local variables.</li>
-     *     <li>Enabling byte-level operations and temporary storage.</li>
-     *     <li>Transferring values from the stack to local scope in compact form.</li>
-     * </ul>
-     */
-    public static final int B_STORE = 154;
-
-
-    /**
-     * D_STORE Opcode: Represents a store operation that stores a double64 value from the operand stack into the local variable store.
-     * <p>This opcode is implemented by the {@link DStoreCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
-     *     <li>Pops a double64 value from the operand stack.</li>
-     *     <li>Stores the value into the local variable store at the specified index of the current method frame.</li>
-     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used for:</p>
-     * <ul>
-     *     <li>Saving double64-precision results after arithmetic or conversion operations.</li>
-     *     <li>Ensuring floating-point values persist in method-local storage.</li>
-     *     <li>Managing precision-critical calculations across instruction sequences.</li>
-     * </ul>
-     */
-    public static final int D_STORE = 155;
-
-    /**
-     * F_STORE Opcode: Represents a store operation that stores a float32 value from the operand stack into the local variable store.
-     * <p>This opcode is implemented by the {@link FStoreCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
-     *     <li>Pops a float32 value from the operand stack.</li>
-     *     <li>Stores the value into the local variable store at the specified index of the current method frame.</li>
-     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used for:</p>
-     * <ul>
-     *     <li>Saving float32 results into method-local variables.</li>
-     *     <li>Supporting floating-point local variable operations.</li>
-     *     <li>Preserving floating-point values between instructions or calls.</li>
-     * </ul>
-     */
-    public static final int F_STORE = 156;
-
-
-    /**
-     * I_LOAD Opcode: Represents a load operation that retrieves an int32 value from the local variable store and pushes it onto the operand stack.
-     * <p>This opcode is implemented by the {@link ILoadCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
-     *     <li>Retrieves the corresponding value from the local variable store of the current method frame.</li>
-     *     <li>Pushes the retrieved value onto the operand stack for subsequent operations.</li>
-     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used for:</p>
-     * <ul>
-     *     <li>Loading local variables onto the operand stack for further operations or computations.</li>
-     *     <li>Retrieving stored values that are needed for subsequent instructions, such as arithmetic or logic operations.</li>
-     *     <li>Preserving the necessary method-local state by pushing relevant values from the local variable store to the operand stack.</li>
-     * </ul>
-     */
-    public static final int I_LOAD = 161;
+    public static final int L_PUSH = 0x006A;
     /**
      * L_LOAD Opcode: Represents a load operation that retrieves a long64 value from the local variable store and pushes it onto the operand stack.
      * <p>This opcode is implemented by the {@link LLoadCommand} class, which defines its specific execution logic.</p>
@@ -1597,67 +1299,283 @@ public class VMOpCode {
      *     <li>Preserving the necessary method-local state by pushing relevant values from the local variable store to the operand stack.</li>
      * </ul>
      */
-    public static final int L_LOAD = 162;
+    public static final int L_LOAD = 0x006B;
     /**
-     * S_LOAD Opcode: Represents a load operation that retrieves a short16 value from the local variable store and pushes it onto the operand stack.
-     * <p>This opcode is implemented by the {@link SLoadCommand} class, which defines its specific execution logic.</p>
+     * L_STORE Opcode: Represents a store operation that stores a long64 value from the operand stack into the local variable store.
+     * <p>This opcode is implemented by the {@link LStoreCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
      *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
-     *     <li>Retrieves the corresponding value from the local variable store of the current method frame.</li>
-     *     <li>Pushes the retrieved value onto the operand stack for subsequent operations.</li>
+     *     <li>Pops a long64 value from the operand stack.</li>
+     *     <li>Stores the value into the local variable store at the specified index of the current method frame.</li>
      *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
      * </ol>
      *
      * <p>This opcode is commonly used for:</p>
      * <ul>
-     *     <li>Loading local variables onto the operand stack for further operations or computations.</li>
-     *     <li>Retrieving stored values that are needed for subsequent instructions, such as arithmetic or logic operations.</li>
-     *     <li>Preserving the necessary method-local state by pushing relevant values from the local variable store to the operand stack.</li>
+     *     <li>Storing computed long64 values into local variables for reuse.</li>
+     *     <li>Preserving long-type data across multiple instructions or calls.</li>
+     *     <li>Moving data from the operand stack to a persistent method-local context.</li>
      * </ul>
      */
-    public static final int S_LOAD = 163;
+    public static final int L_STORE = 0x006C;
     /**
-     * B_LOAD Opcode: Represents a load operation that retrieves a byte8 value from the local variable store and pushes it onto the operand stack.
-     * <p>This opcode is implemented by the {@link BLoadCommand} class, which defines its specific execution logic.</p>
+     * L_CE Opcode: Represents a conditional jump based on long64 equality.
+     * <p>This opcode is implemented by the {@link LCECommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
-     *     <li>Retrieves the corresponding value from the local variable store of the current method frame.</li>
-     *     <li>Pushes the retrieved value onto the operand stack for subsequent operations.</li>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two long64 values from the operand stack.</li>
+     *     <li>Compares the two long64 for equality.</li>
+     *     <li>If the long64 are equal, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the long64 are not equal, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on long64 comparison.</li>
+     *     <li>Implementing control flow structures such as if-statements and loops.</li>
+     * </ul>
+     */
+    public static final int L_CE = 0x006D;
+    /**
+     * L_CNE Opcode: Represents a conditional jump based on long64 inequality.
+     * <p>This opcode is implemented by the {@link LCNECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two long64 values from the operand stack.</li>
+     *     <li>Compares the two long64 for inequality.</li>
+     *     <li>If the long64 are not equal, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the long64 are equal, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on long64 comparison.</li>
+     *     <li>Implementing control flow structures such as conditional loops and if-else statements.</li>
+     * </ul>
+     */
+    public static final int L_CNE = 0x006E;
+    /**
+     * L_CG Opcode: Represents a conditional jump based on long64 comparison (greater than).
+     * <p>This opcode is implemented by the {@link LCGCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two long64 values from the operand stack.</li>
+     *     <li>Compares the first long64 with the second to determine if it is greater.</li>
+     *     <li>If the first long64 is greater than the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first long64 is not greater than the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on long64 comparison.</li>
+     *     <li>Implementing control flow structures such as greater-than conditions in loops and conditional statements.</li>
+     * </ul>
+     */
+    public static final int L_CG = 0x006F;
+    /**
+     * L_CGE Opcode: Represents a conditional jump based on long64 comparison (greater than or equal to).
+     * <p>This opcode is implemented by the {@link LCGECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two long64 values from the operand stack.</li>
+     *     <li>Compares the first long64 with the second to determine if it is greater than or equal to the second long64.</li>
+     *     <li>If the first long64 is greater than or equal to the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first long64 is less than the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on long64 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and range checks.</li>
+     * </ul>
+     */
+    public static final int L_CGE = 0x0070;
+    /**
+     * L_CL Opcode: Represents a conditional jump based on long64 comparison (less than).
+     * <p>This opcode is implemented by the {@link LCLCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two long64 values from the operand stack.</li>
+     *     <li>Compares the first long64 with the second to determine if it is less than the second long64.</li>
+     *     <li>If the first long64 is less than the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first long64 is greater than or equal to the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on long64 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and range validations.</li>
+     * </ul>
+     */
+    public static final int L_CL = 0x0071;
+    /**
+     * L_CLE Opcode: Represents a conditional jump based on long64 comparison (less than or equal).
+     * <p>This opcode is implemented by the {@link LCLECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two long64 values from the operand stack.</li>
+     *     <li>Compares the first long64 with the second to determine if it is less than or equal to the second long64.</li>
+     *     <li>If the first long64 is less than or equal to the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first long64 is greater than the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on long64 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and boundary checks.</li>
+     * </ul>
+     */
+    public static final int L_CLE = 0x0072;
+    // endregion
+
+    // region Float32 (0x0080-0x009F)
+    /**
+     * F_ADD Opcode: Represents the float32 addition operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link FAddCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two float32 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
+     *     <li>Performs the float32 addition operation on these two operands.</li>
+     *     <li>Pushes the result of the addition back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic float32 addition tasks.</p>
+     */
+    public static final int F_ADD = 0x0080;
+    /**
+     * F_SUB Opcode: Represents the float32 subtraction operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link FSubCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two float32 values from the operand stack (the first value popped is the subtrahend, and the second value popped is the minuend).</li>
+     *     <li>Performs the float32 subtraction operation by subtracting the subtrahend from the minuend (i.e., <code>minuend - subtrahend</code>).</li>
+     *     <li>Pushes the result of the subtraction back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic float32 subtraction tasks.</p>
+     */
+    public static final int F_SUB = 0x0081;
+    /**
+     * F_MUL Opcode: Represents the float32 multiplication operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link FMulCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two float32 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
+     *     <li>Performs the float32 multiplication operation on these two operands (i.e., <code>firstOperand * secondOperand</code>).</li>
+     *     <li>Pushes the result of the multiplication back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic float32 multiplication tasks.</p>
+     */
+    public static final int F_MUL = 0x0082;
+    /**
+     * F_DIV Opcode: Represents the float32 division operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link FDivCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two float32 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
+     *     <li>Performs the float32 division operation by dividing the dividend by the divisor (i.e., <code>dividend / divisor</code>).</li>
+     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
+     *     <li>Pushes the result of the division back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic float32 division tasks.</p>
+     */
+    public static final int F_DIV = 0x0083;
+    /**
+     * F_MOD Opcode: Represents the float32 modulus (remainder) operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link FModCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two float32 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
+     *     <li>Performs the modulus operation by calculating the remainder of the division of the dividend by the divisor (i.e., <code>dividend % divisor</code>).</li>
+     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
+     *     <li>Pushes the result of the modulus operation back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic float32 modulus (remainder) tasks.</p>
+     */
+    public static final int F_MOD = 0x0084;
+    /**
+     * F_NEG Opcode: Represents the float32 negation operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link FNegCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top float32 value from the operand stack.</li>
+     *     <li>Performs the negation of the popped value (i.e., <code>-value</code>).</li>
+     *     <li>Pushes the negated result back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is typically used to negate a float32 value, making it a fundamental operation for float32 arithmetic logic within the virtual machine.</p>
+     */
+    public static final int F_NEG = 0x0085;
+    /**
+     * F_INC Opcode: Represents the float32 increment operation for a local variable in the virtual machine.
+     * <p>This opcode is implemented by the {@link FIncCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Retrieves the index of the local variable and the increment value from the instruction parameters.</li>
+     *     <li>Gets the current value of the local variable at the specified index from the local variable store.</li>
+     *     <li>Increments the local variable's value by the specified increment (i.e.,
+     *         <code>localVariables[index] += increment</code>).</li>
+     *     <li>Updates the local variable store with the new incremented value.</li>
+     *     <li>Returns the updated program counter (PC) value, typically incremented by 1, unless control flow changes.</li>
+     * </ol>
+     *
+     * <p>This opcode is particularly useful for optimizing scenarios where a local `float32` variable, such as a counter or loop index, is frequently incremented.</p>
+     */
+    public static final int F_INC = 0x0086;
+    /**
+     * F_PUSH Opcode: Represents a stack operation that pushes a float32 value onto the operand stack.
+     * <p>This opcode is implemented by the {@link FPushCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the float32 value from the instruction parameters.</li>
+     *     <li>Pushes the parsed float32 value onto the operand stack.</li>
      *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
      * </ol>
      *
      * <p>This opcode is commonly used for:</p>
      * <ul>
-     *     <li>Loading local variables onto the operand stack for further operations or computations.</li>
-     *     <li>Retrieving stored values that are needed for subsequent instructions, such as arithmetic or logic operations.</li>
-     *     <li>Preserving the necessary method-local state by pushing relevant values from the local variable store to the operand stack.</li>
+     *     <li>Loading constant values into the operand stack for later operations.</li>
+     *     <li>Preparing operands for arithmetic, logical, or comparison instructions.</li>
+     *     <li>Facilitating method calls or control flow by managing stack-based data.</li>
      * </ul>
      */
-    public static final int B_LOAD = 164;
-    /**
-     * D_LOAD Opcode: Represents a load operation that retrieves a double64 value from the local variable store and pushes it onto the operand stack.
-     * <p>This opcode is implemented by the {@link DLoadCommand} class, which defines its specific execution logic.</p>
-     *
-     * <p>Execution Steps:</p>
-     * <ol>
-     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
-     *     <li>Retrieves the corresponding value from the local variable store of the current method frame.</li>
-     *     <li>Pushes the retrieved value onto the operand stack for subsequent operations.</li>
-     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
-     * </ol>
-     *
-     * <p>This opcode is commonly used for:</p>
-     * <ul>
-     *     <li>Loading local variables onto the operand stack for further operations or computations.</li>
-     *     <li>Retrieving stored values that are needed for subsequent instructions, such as arithmetic or logic operations.</li>
-     *     <li>Preserving the necessary method-local state by pushing relevant values from the local variable store to the operand stack.</li>
-     * </ul>
-     */
-    public static final int D_LOAD = 165;
+    public static final int F_PUSH = 0x0087;
     /**
      * F_LOAD Opcode: Represents a load operation that retrieves a float32 value from the local variable store and pushes it onto the operand stack.
      * <p>This opcode is implemented by the {@link FLoadCommand} class, which defines its specific execution logic.</p>
@@ -1677,28 +1595,761 @@ public class VMOpCode {
      *     <li>Preserving the necessary method-local state by pushing relevant values from the local variable store to the operand stack.</li>
      * </ul>
      */
-    public static final int F_LOAD = 166;
-
+    public static final int F_LOAD = 0x0088;
     /**
-     * MOV Opcode: Represents a move operation that transfers a value from one local variable to another within the local variable store.
-     * <p>This opcode is implemented by the {@link MovCommand} class, which defines its specific execution logic.</p>
+     * F_STORE Opcode: Represents a store operation that stores a float32 value from the operand stack into the local variable store.
+     * <p>This opcode is implemented by the {@link FStoreCommand} class, which defines its specific execution logic.</p>
      *
      * <p>Execution Steps:</p>
      * <ol>
-     *     <li>Parses the source and destination indices from the instruction parameters.</li>
-     *     <li>Retrieves the value from the local variable store at the source index.</li>
-     *     <li>Stores the retrieved value into the destination index of the local variable store.</li>
+     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
+     *     <li>Pops a float32 value from the operand stack.</li>
+     *     <li>Stores the value into the local variable store at the specified index of the current method frame.</li>
      *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
      * </ol>
      *
      * <p>This opcode is commonly used for:</p>
      * <ul>
-     *     <li>Transferring values between local variables within a method frame.</li>
-     *     <li>Preserving computed results by moving them to designated local variable slots.</li>
-     *     <li>Facilitating intermediate storage of values needed for later computations.</li>
+     *     <li>Saving float32 results into method-local variables.</li>
+     *     <li>Supporting floating-point local variable operations.</li>
+     *     <li>Preserving floating-point values between instructions or calls.</li>
      * </ul>
      */
-    public static final int MOV = 171;
+    public static final int F_STORE = 0x0089;
+    /**
+     * L_CE Opcode: Represents a conditional jump based on float32 equality.
+     * <p>This opcode is implemented by the {@link LCECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two float32 values from the operand stack.</li>
+     *     <li>Compares the two float32 for equality.</li>
+     *     <li>If the float32 are equal, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the float32 are not equal, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on float32 comparison.</li>
+     *     <li>Implementing control flow structures such as if-statements and loops.</li>
+     * </ul>
+     */
+    public static final int F_CE = 0x008A;
+    /**
+     * L_CNE Opcode: Represents a conditional jump based on float32 inequality.
+     * <p>This opcode is implemented by the {@link LCNECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two float32 values from the operand stack.</li>
+     *     <li>Compares the two float32 for inequality.</li>
+     *     <li>If the float32 are not equal, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the float32 are equal, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on float32 comparison.</li>
+     *     <li>Implementing control flow structures such as conditional loops and if-else statements.</li>
+     * </ul>
+     */
+    public static final int F_CNE = 0x008B;
+    /**
+     * L_CG Opcode: Represents a conditional jump based on float32 comparison (greater than).
+     * <p>This opcode is implemented by the {@link LCGCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two float32 values from the operand stack.</li>
+     *     <li>Compares the first float32 with the second to determine if it is greater.</li>
+     *     <li>If the first float32 is greater than the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first float32 is not greater than the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on float32 comparison.</li>
+     *     <li>Implementing control flow structures such as greater-than conditions in loops and conditional statements.</li>
+     * </ul>
+     */
+    public static final int F_CG = 0x008C;
+    /**
+     * L_CGE Opcode: Represents a conditional jump based on float32 comparison (greater than or equal to).
+     * <p>This opcode is implemented by the {@link LCGECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two float32 values from the operand stack.</li>
+     *     <li>Compares the first float32 with the second to determine if it is greater than or equal to the second float32.</li>
+     *     <li>If the first float32 is greater than or equal to the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first float32 is less than the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on float32 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and range checks.</li>
+     * </ul>
+     */
+    public static final int F_CGE = 0x008D;
+    /**
+     * L_CL Opcode: Represents a conditional jump based on float32 comparison (less than).
+     * <p>This opcode is implemented by the {@link LCLCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two float32 values from the operand stack.</li>
+     *     <li>Compares the first float32 with the second to determine if it is less than the second float32.</li>
+     *     <li>If the first float32 is less than the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first float32 is greater than or equal to the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on float32 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and range validations.</li>
+     * </ul>
+     */
+    public static final int F_CL = 0x008E;
+    /**
+     * L_CLE Opcode: Represents a conditional jump based on float32 comparison (less than or equal).
+     * <p>This opcode is implemented by the {@link LCLECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two float32 values from the operand stack.</li>
+     *     <li>Compares the first float32 with the second to determine if it is less than or equal to the second float32.</li>
+     *     <li>If the first float32 is less than or equal to the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first float32 is greater than the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on float32 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and boundary checks.</li>
+     * </ul>
+     */
+    public static final int F_CLE = 0x008F;
+    // endregion
+
+    // region Double64 (0x00A0-0x00BF)
+    /**
+     * D_ADD Opcode: Represents the double64 precision floating-point addition operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link DAddCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two double64 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
+     *     <li>Performs the double64 precision floating-point addition operation on these two operands.</li>
+     *     <li>Pushes the result of the addition back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic double64 precision floating-point addition tasks.</p>
+     */
+    public static final int D_ADD = 0x00A0;
+    /**
+     * D_SUB Opcode: Represents the double64 precision floating-point subtraction operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link DSubCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two double64 values from the operand stack (the first value popped is the subtrahend, and the second value popped is the minuend).</li>
+     *     <li>Performs the double64 precision floating-point subtraction operation by subtracting the subtrahend from the minuend (i.e., <code>minuend - subtrahend</code>).</li>
+     *     <li>Pushes the result of the subtraction back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic double64 precision floating-point subtraction tasks.</p>
+     */
+    public static final int D_SUB = 0x00A1;
+    /**
+     * D_MUL Opcode: Represents the double64 precision floating-point multiplication operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link DMulCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two double64 values from the operand stack (the first value popped is the second operand, and the second value popped is the first operand).</li>
+     *     <li>Performs the double64 precision floating-point multiplication operation on these two operands (i.e., <code>firstOperand * secondOperand</code>).</li>
+     *     <li>Pushes the result of the multiplication back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic double64 precision floating-point multiplication tasks.</p>
+     */
+    public static final int D_MUL = 0x00A2;
+    /**
+     * D_DIV Opcode: Represents the double64 precision floating-point division operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link DDivCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two double64 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
+     *     <li>Performs the double64 precision floating-point division operation by dividing the dividend by the divisor (i.e., <code>dividend / divisor</code>).</li>
+     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
+     *     <li>Pushes the result of the division back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic double64 precision floating-point division tasks.</p>
+     */
+    public static final int D_DIV = 0x00A3;
+    /**
+     * D_MOD Opcode: Represents the double64 precision floating-point modulus (remainder) operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link DModCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top two double64 values from the operand stack (the first value popped is the divisor, and the second value popped is the dividend).</li>
+     *     <li>Performs the modulus operation by calculating the remainder of the division of the dividend by the divisor (i.e., <code>dividend % divisor</code>).</li>
+     *     <li>Checks for division by zero and throws an {@link ArithmeticException} if the divisor is zero, as this operation is undefined.</li>
+     *     <li>Pushes the result of the modulus operation back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is a fundamental arithmetic operation within the virtual machine's instruction set,
+     * primarily used to handle basic double64 precision floating-point modulus (remainder) tasks.</p>
+     */
+    public static final int D_MOD = 0x00A4;
+    /**
+     * D_NEG Opcode: Represents the double64 precision floating-point negation operation in the virtual machine.
+     * <p>This opcode is implemented by the {@link DNegCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pops the top double64 value from the operand stack.</li>
+     *     <li>Performs the negation of the popped value (i.e., <code>-value</code>).</li>
+     *     <li>Pushes the negated result back onto the operand stack for later instructions to use.</li>
+     * </ol>
+     *
+     * <p>This opcode is typically used to negate a double64 precision floating-point value, making it a fundamental operation for double64 precision arithmetic logic within the virtual machine.</p>
+     */
+    public static final int D_NEG = 0x00A5;
+    /**
+     * D_INC Opcode: Represents the double64 increment operation for a local variable in the virtual machine.
+     * <p>This opcode is implemented by the {@link DIncCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Retrieves the index of the local variable and the increment value from the instruction parameters.</li>
+     *     <li>Gets the current value of the local variable at the specified index from the local variable store.</li>
+     *     <li>Increments the local variable's value by the specified increment (i.e.,
+     *         <code>localVariables[index] += increment</code>).</li>
+     *     <li>Updates the local variable store with the new incremented value.</li>
+     *     <li>Returns the updated program counter (PC) value, typically incremented by 1, unless control flow changes.</li>
+     * </ol>
+     *
+     * <p>This opcode is particularly useful for optimizing scenarios where a local `double64` variable, such as a counter or loop index, is frequently incremented.</p>
+     */
+    public static final int D_INC = 0x00A6;
+    /**
+     * D_PUSH Opcode: Represents a stack operation that pushes a double64 value onto the operand stack.
+     * <p>This opcode is implemented by the {@link DPushCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the double64 value from the instruction parameters.</li>
+     *     <li>Pushes the parsed double64 value onto the operand stack.</li>
+     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Loading constant values into the operand stack for later operations.</li>
+     *     <li>Preparing operands for arithmetic, logical, or comparison instructions.</li>
+     *     <li>Facilitating method calls or control flow by managing stack-based data.</li>
+     * </ul>
+     */
+    public static final int D_PUSH = 0x00A7;
+    /**
+     * D_LOAD Opcode: Represents a load operation that retrieves a double64 value from the local variable store and pushes it onto the operand stack.
+     * <p>This opcode is implemented by the {@link DLoadCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
+     *     <li>Retrieves the corresponding value from the local variable store of the current method frame.</li>
+     *     <li>Pushes the retrieved value onto the operand stack for subsequent operations.</li>
+     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Loading local variables onto the operand stack for further operations or computations.</li>
+     *     <li>Retrieving stored values that are needed for subsequent instructions, such as arithmetic or logic operations.</li>
+     *     <li>Preserving the necessary method-local state by pushing relevant values from the local variable store to the operand stack.</li>
+     * </ul>
+     */
+    public static final int D_LOAD = 0x00A8;
+    /**
+     * D_STORE Opcode: Represents a store operation that stores a double64 value from the operand stack into the local variable store.
+     * <p>This opcode is implemented by the {@link DStoreCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Retrieves the index for the local variable from the instruction parameters.</li>
+     *     <li>Pops a double64 value from the operand stack.</li>
+     *     <li>Stores the value into the local variable store at the specified index of the current method frame.</li>
+     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Saving double64-precision results after arithmetic or conversion operations.</li>
+     *     <li>Ensuring floating-point values persist in method-local storage.</li>
+     *     <li>Managing precision-critical calculations across instruction sequences.</li>
+     * </ul>
+     */
+    public static final int D_STORE = 0x00A9;
+    /**
+     * L_CE Opcode: Represents a conditional jump based on double64 equality.
+     * <p>This opcode is implemented by the {@link LCECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two double64 values from the operand stack.</li>
+     *     <li>Compares the two double64 for equality.</li>
+     *     <li>If the double64 are equal, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the double64 are not equal, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on double64 comparison.</li>
+     *     <li>Implementing control flow structures such as if-statements and loops.</li>
+     * </ul>
+     */
+    public static final int D_CE = 0x00AA;
+    /**
+     * L_CNE Opcode: Represents a conditional jump based on double64 inequality.
+     * <p>This opcode is implemented by the {@link LCNECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two double64 values from the operand stack.</li>
+     *     <li>Compares the two double64 for inequality.</li>
+     *     <li>If the double64 are not equal, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the double64 are equal, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on double64 comparison.</li>
+     *     <li>Implementing control flow structures such as conditional loops and if-else statements.</li>
+     * </ul>
+     */
+    public static final int D_CNE = 0x00AB;
+    /**
+     * L_CG Opcode: Represents a conditional jump based on double64 comparison (greater than).
+     * <p>This opcode is implemented by the {@link LCGCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two double64 values from the operand stack.</li>
+     *     <li>Compares the first double64 with the second to determine if it is greater.</li>
+     *     <li>If the first double64 is greater than the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first double64 is not greater than the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on double64 comparison.</li>
+     *     <li>Implementing control flow structures such as greater-than conditions in loops and conditional statements.</li>
+     * </ul>
+     */
+    public static final int D_CG = 0x00AC;
+    /**
+     * L_CGE Opcode: Represents a conditional jump based on double64 comparison (greater than or equal to).
+     * <p>This opcode is implemented by the {@link LCGECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two double64 values from the operand stack.</li>
+     *     <li>Compares the first double64 with the second to determine if it is greater than or equal to the second double64.</li>
+     *     <li>If the first double64 is greater than or equal to the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first double64 is less than the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on double64 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and range checks.</li>
+     * </ul>
+     */
+    public static final int D_CGE = 0x00AD;
+    /**
+     * L_CL Opcode: Represents a conditional jump based on double64 comparison (less than).
+     * <p>This opcode is implemented by the {@link LCLCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two double64 values from the operand stack.</li>
+     *     <li>Compares the first double64 with the second to determine if it is less than the second double64.</li>
+     *     <li>If the first double64 is less than the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first double64 is greater than or equal to the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on double64 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and range validations.</li>
+     * </ul>
+     */
+    public static final int D_CL = 0x00AE;
+    /**
+     * L_CLE Opcode: Represents a conditional jump based on double64 comparison (less than or equal).
+     * <p>This opcode is implemented by the {@link LCLECommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Pops two double64 values from the operand stack.</li>
+     *     <li>Compares the first double64 with the second to determine if it is less than or equal to the second double64.</li>
+     *     <li>If the first double64 is less than or equal to the second, updates the program counter (PC) to the specified target address,
+     *         effectively jumping to the target instruction.</li>
+     *     <li>If the first double64 is greater than the second, increments the program counter to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Conditional branching in virtual machine execution based on double64 comparison.</li>
+     *     <li>Implementing control flow structures such as loops, conditional statements, and boundary checks.</li>
+     * </ul>
+     */
+    public static final int D_CLE = 0x00AF;
+
+    // endregion
+    // endregion
+
+    // region Type Conversion (0x00C0-0x00DF)
+    /**
+     * I2L Opcode: Represents the type conversion operation from int32 to long64 in the virtual machine.
+     * <p>This opcode is implemented by the {@link I2LCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top int32 value from the operand stack.</li>
+     *     <li>Convert the int32 value to a long64 value.</li>
+     *     <li>Push the converted long64 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used to widen an int32 value to a long64 type to accommodate larger numeric ranges.</p>
+     */
+    public static final int I2L = 0x00C0;
+    /**
+     * I2S Opcode: Represents the type conversion operation from int32 to short16 in the virtual machine.
+     * <p>This opcode is implemented by the {@link I2SCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top int32 value from the operand stack.</li>
+     *     <li>Convert the int32 value to a short16 value (this may involve truncation).</li>
+     *     <li>Push the converted short16 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is typically used to narrow an int32 value to a short16 type when a smaller data representation is needed.</p>
+     */
+    public static final int I2S = 0x00C1;
+    /**
+     * I2B Opcode: Represents the type conversion operation from int32 to byte8 in the virtual machine.
+     * <p>This opcode is implemented by the {@link I2BCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top int32 value from the operand stack.</li>
+     *     <li>Convert the int32 value to a byte8 value (this may involve truncation).</li>
+     *     <li>Push the converted byte8 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is used to narrow an int32 value to a byte8 type, suitable when a smaller numeric type is required.</p>
+     */
+    public static final int I2B = 0x00C2;
+    /**
+     * I2D Opcode: Represents the type conversion operation from int32 to double64 in the virtual machine.
+     * <p>This opcode is implemented by the {@link I2DCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top int32 value from the operand stack.</li>
+     *     <li>Convert the int32 value to a double64 value.</li>
+     *     <li>Push the converted double64 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is used to widen an int32 value to a double64 type, providing high-precision floating-point calculations.</p>
+     */
+    public static final int I2D = 0x00C3;
+    /**
+     * I2F Opcode: Represents the type conversion operation from int32 to float32 in the virtual machine.
+     * <p>This opcode is implemented by the {@link I2FCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top int32 value from the operand stack.</li>
+     *     <li>Convert the int32 value to a float32 value.</li>
+     *     <li>Push the converted float32 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is used to convert an int32 value to a float32 type when floating-point arithmetic is required.</p>
+     */
+    public static final int I2F = 0x00C4;
+    /**
+     * L2I Opcode: Represents the type conversion operation from long64 to int32 in the virtual machine.
+     * <p>This opcode is implemented by the {@link L2ICommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top long64 value from the operand stack.</li>
+     *     <li>Convert the long64 value to an int32 value (this may involve truncation).</li>
+     *     <li>Push the converted int32 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is typically used to narrow a long64 value to an int32 type for further integer operations.</p>
+     */
+    public static final int L2I = 0x00C5;
+    /**
+     * L2D Opcode: Represents the type conversion operation from long64 to double64 in the virtual machine.
+     * <p>This opcode is implemented by the {@link L2DCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top long64 value from the operand stack.</li>
+     *     <li>Convert the long64 value to a double64 value.</li>
+     *     <li>Push the converted double64 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is used to widen a long64 value to a double64 type for high-precision floating-point computations.</p>
+     */
+    public static final int L2D = 0x00C6;
+    /**
+     * L2F Opcode: Represents the type conversion operation from long64 to float32 in the virtual machine.
+     * <p>This opcode is implemented by the {@link L2FCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top long64 value from the operand stack.</li>
+     *     <li>Convert the long64 value to a float32 value.</li>
+     *     <li>Push the converted float32 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is used to convert a long64 value to a float32 type, typically for floating-point arithmetic involving long values.</p>
+     */
+    public static final int L2F = 0x00C7;
+    /**
+     * F2I Opcode: Represents the type conversion operation from float32 to int32 in the virtual machine.
+     * <p>This opcode is implemented by the {@link F2ICommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top float32 value from the operand stack.</li>
+     *     <li>Convert the float32 value to an int32 value (this may involve truncation).</li>
+     *     <li>Push the converted int32 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is used to convert a float32 value to an int32 type for further integer-based operations or comparisons.</p>
+     */
+    public static final int F2I = 0x00C8;
+    /**
+     * F2L Opcode: Represents the type conversion operation from float32 to long64 in the virtual machine.
+     * <p>This opcode is implemented by the {@link F2LCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top float32 value from the operand stack.</li>
+     *     <li>Convert the float32 value to a long64 value.</li>
+     *     <li>Push the converted long64 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is used to widen a float32 value to a long64 type, which is useful when operations require a larger numeric range.</p>
+     */
+    public static final int F2L = 0x00C9;
+    /**
+     * F2D Opcode: Represents the type conversion operation from float32 to double64 in the virtual machine.
+     * <p>This opcode is implemented by the {@link F2DCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top float32 value from the operand stack.</li>
+     *     <li>Convert the float32 value to a double64 value.</li>
+     *     <li>Push the converted double64 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is used to promote a float32 value to a double64 type, thereby increasing precision for floating-point computations.</p>
+     */
+    public static final int F2D = 0x00CA;
+    /**
+     * D2I Opcode: Represents the type conversion operation from double64 to int32 in the virtual machine.
+     * <p>This opcode is implemented by the {@link D2ICommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top double64 value from the operand stack.</li>
+     *     <li>Convert the double64 value to an int32 value (this may involve truncation).</li>
+     *     <li>Push the converted int32 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is used to narrow a double64 value to an int32 type for further integer-based processing.</p>
+     */
+    public static final int D2I = 0x00CB;
+    /**
+     * D2L Opcode: Represents the type conversion operation from double64 to long64 in the virtual machine.
+     * <p>This opcode is implemented by the {@link D2LCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top double64 value from the operand stack.</li>
+     *     <li>Convert the double64 value to a long64 value (this may involve truncation).</li>
+     *     <li>Push the converted long64 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is used to narrow a double64 value to a long64 type, which can then be used for integer operations.</p>
+     */
+    public static final int D2L = 0x00CC;
+    /**
+     * D2F Opcode: Represents the type conversion operation from double64 to float32 in the virtual machine.
+     * <p>This opcode is implemented by the {@link D2FCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top double64 value from the operand stack.</li>
+     *     <li>Convert the double64 value to a float32 value.</li>
+     *     <li>Push the converted float32 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is used to narrow a double64 value to a float32 type when lower precision floating-point arithmetic is acceptable.</p>
+     */
+    public static final int D2F = 0x00CD;
+    /**
+     * S2I Opcode: Represents the type conversion operation from short16 to int32 in the virtual machine.
+     * <p>This opcode is implemented by the {@link S2ICommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top short16 value from the operand stack.</li>
+     *     <li>Convert the short16 value to an int32 value.</li>
+     *     <li>Push the converted int32 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is used to widen a short16 value to an int32 type, facilitating subsequent integer arithmetic or comparison operations.</p>
+     */
+    public static final int S2I = 0x00CE;
+    /**
+     * B2I Opcode: Represents the type conversion operation from byte8 to int32 in the virtual machine.
+     * <p>This opcode is implemented by the {@link B2ICommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Pop the top byte8 value from the operand stack.</li>
+     *     <li>Convert the byte8 value to an int32 value.</li>
+     *     <li>Push the converted int32 value back onto the operand stack for subsequent operations.</li>
+     * </ol>
+     *
+     * <p>This opcode is used to widen a byte8 value to an int32 type to ensure compatibility with integer-based operations.</p>
+     */
+    public static final int B2I = 0x00CF;
+    // endregion
+
+    // region Stack Control (0x0100-0x01FF)
+    /**
+     * POP Opcode: Represents a stack operation that removes the top element from the operand stack.
+     * <p>This opcode is implemented by the {@link PopCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Removes (pops) the top element from the operand stack.</li>
+     *     <li>Discards the popped value, as it is not stored or used further.</li>
+     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Clearing temporary or unnecessary data from the operand stack.</li>
+     *     <li>Managing stack cleanup after operations that leave excess data.</li>
+     *     <li>Ensuring stack balance during function calls or control flow transitions.</li>
+     * </ul>
+     */
+    public static final int POP = 0x0100;
+    /**
+     * DUP Opcode: Represents a stack operation that duplicates the top element of the operand stack.
+     * <p>This opcode is implemented by the {@link DupCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Retrieves the top element from the operand stack.</li>
+     *     <li>Duplicates the top value and pushes it back onto the stack.</li>
+     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Preserving the top element of the operand stack for later use in later operations.</li>
+     *     <li>Duplicating values that are needed multiple times in the execution flow.</li>
+     *     <li>Managing stack balance when performing operations that require repeated access to the same data.</li>
+     * </ul>
+     */
+    public static final int DUP = 0x0101;
+    /**
+     * SWAP Opcode: Represents a stack operation that swaps the top two values of the operand stack.
+     * <p>This opcode is implemented by the {@link SwapCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Ensures that there are at least two elements on the operand stack.</li>
+     *     <li>Pops the two topmost values from the stack.</li>
+     *     <li>Pushes the two values back onto the stack in reversed order.</li>
+     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Reversing the order of the top two elements on the stack, which may be required in certain algorithms or operations.</li>
+     *     <li>Handling data rearrangements that require immediate swapping of operands during execution.</li>
+     *     <li>Ensuring proper operand placement for later instructions that depend on the order of stack elements.</li>
+     * </ul>
+     */
+    public static final int SWAP = 0x0102;
+    // endregion
+
+    // region Flow Control (0x0200-0x02FF)
+    /**
+     * JUMP Opcode: Represents an unconditional jump to a target instruction address.
+     * <p>This opcode is implemented by the {@link JumpCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the target instruction address from the instruction parameters.</li>
+     *     <li>Validates the target address to ensure it is a non-negative int32.</li>
+     *     <li>If the target address is valid (greater than or equal to 0), updates the program counter (PC) to the specified target address,
+     *         effectively skipping all intermediate instructions.</li>
+     *     <li>If the target address is invalid (less than 0), logs an error message and halts execution by returning an invalid value (typically -1).</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Control flow management in virtual machine execution.</li>
+     * </ul>
+     */
+    public static final int JUMP = 0x0200;
     /**
      * CALL Opcode: Represents a function or subroutine call operation that transfers control to a specified function address.
      * <p>This opcode is implemented by the {@link CallCommand} class, which defines its specific execution logic.</p>
@@ -1718,7 +2369,7 @@ public class VMOpCode {
      *     <li>Facilitating modular and reusable code execution by enabling jumps to specific function addresses.</li>
      * </ul>
      */
-    public static final int CALL = 201;
+    public static final int CALL = 0x0201;
     /**
      * RET Opcode: Represents a return operation that transfers control back to the calling method by restoring the saved return address.
      * <p>This opcode is implemented by the {@link RetCommand} class, which defines its specific execution logic.</p>
@@ -1738,7 +2389,33 @@ public class VMOpCode {
      *     <li>Cleaning up the local variables of the completed method to maintain memory consistency.</li>
      * </ul>
      */
-    public static final int RET = 202;
+    public static final int RET = 0x0202;
+    // endregion
+
+    // region Register Control (0x0300-0x03FF)
+    /**
+     * MOV Opcode: Represents a move operation that transfers a value from one local variable to another within the local variable store.
+     * <p>This opcode is implemented by the {@link MovCommand} class, which defines its specific execution logic.</p>
+     *
+     * <p>Execution Steps:</p>
+     * <ol>
+     *     <li>Parses the source and destination indices from the instruction parameters.</li>
+     *     <li>Retrieves the value from the local variable store at the source index.</li>
+     *     <li>Stores the retrieved value into the destination index of the local variable store.</li>
+     *     <li>Increments the program counter (PC) to proceed with the next sequential instruction.</li>
+     * </ol>
+     *
+     * <p>This opcode is commonly used for:</p>
+     * <ul>
+     *     <li>Transferring values between local variables within a method frame.</li>
+     *     <li>Preserving computed results by moving them to designated local variable slots.</li>
+     *     <li>Facilitating intermediate storage of values needed for later computations.</li>
+     * </ul>
+     */
+    public static final int MOV = 0x0300;
+    // endregion
+
+    // region  System Control (0x0400-0x04FF)
     /**
      * HALT Opcode: Represents a termination operation that stops the execution of the virtual machine.
      * <p>This opcode is implemented by the {@link HaltCommand} class, which defines its specific execution logic.</p>
@@ -1755,10 +2432,10 @@ public class VMOpCode {
      *     <li>Serving as the final instruction in a program to indicate normal completion.</li>
      * </ul>
      */
-    public static final int HALT = 255;
-
-
-    // VI. Function Operations (50–59)
+    public static final int HALT = 0x0400;
+    public static final int SYSCALL = 0x0401;
+    public static final int DEBUG_TRAP = 0x0402;
+    // endregion
 
     /**
      * Default constructor for creating an instance of VMOpCode.
@@ -1767,4 +2444,4 @@ public class VMOpCode {
     public VMOpCode() {
         // Empty constructor
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/org/jcnc/snow/vm/factories/CommandFactory.java b/src/main/java/org/jcnc/snow/vm/factories/CommandFactory.java
index 5c8c61b..a5af00b 100644
--- a/src/main/java/org/jcnc/snow/vm/factories/CommandFactory.java
+++ b/src/main/java/org/jcnc/snow/vm/factories/CommandFactory.java
@@ -1,47 +1,52 @@
 package org.jcnc.snow.vm.factories;
 
-import org.jcnc.snow.vm.commands.arithmetic.conversion.*;
-import org.jcnc.snow.vm.interfaces.Command;
-import org.jcnc.snow.vm.commands.arithmetic.byte8.*;
-import org.jcnc.snow.vm.commands.arithmetic.double64.*;
-import org.jcnc.snow.vm.commands.arithmetic.float32.*;
-import org.jcnc.snow.vm.commands.arithmetic.int32.*;
-import org.jcnc.snow.vm.commands.arithmetic.long64.*;
-import org.jcnc.snow.vm.commands.arithmetic.short16.*;
-import org.jcnc.snow.vm.commands.bitwise.int32.IAndCommand;
-import org.jcnc.snow.vm.commands.bitwise.int32.IOrCommand;
-import org.jcnc.snow.vm.commands.bitwise.int32.IXorCommand;
-import org.jcnc.snow.vm.commands.bitwise.long64.LAndCommand;
-import org.jcnc.snow.vm.commands.bitwise.long64.LOrCommand;
-import org.jcnc.snow.vm.commands.bitwise.long64.LXorCommand;
-import org.jcnc.snow.vm.commands.control.all.JumpCommand;
-import org.jcnc.snow.vm.commands.control.int32.*;
-import org.jcnc.snow.vm.commands.function.CallCommand;
-import org.jcnc.snow.vm.commands.function.RetCommand;
-import org.jcnc.snow.vm.commands.memory.all.MovCommand;
-import org.jcnc.snow.vm.commands.memory.byte8.BLoadCommand;
-import org.jcnc.snow.vm.commands.memory.byte8.BStoreCommand;
-import org.jcnc.snow.vm.commands.memory.double64.DLoadCommand;
-import org.jcnc.snow.vm.commands.memory.double64.DStoreCommand;
-import org.jcnc.snow.vm.commands.memory.float32.FLoadCommand;
-import org.jcnc.snow.vm.commands.memory.float32.FStoreCommand;
-import org.jcnc.snow.vm.commands.memory.int32.ILoadCommand;
-import org.jcnc.snow.vm.commands.memory.int32.IStoreCommand;
-import org.jcnc.snow.vm.commands.memory.long64.LLoadCommand;
-import org.jcnc.snow.vm.commands.memory.long64.LStoreCommand;
-import org.jcnc.snow.vm.commands.memory.short16.SLoadCommand;
-import org.jcnc.snow.vm.commands.memory.short16.SStoreCommand;
-import org.jcnc.snow.vm.commands.stack.all.DupCommand;
-import org.jcnc.snow.vm.commands.stack.all.PopCommand;
-import org.jcnc.snow.vm.commands.stack.all.SwapCommand;
-import org.jcnc.snow.vm.commands.stack.byte8.BPushCommand;
-import org.jcnc.snow.vm.commands.stack.double64.DPushCommand;
-import org.jcnc.snow.vm.commands.stack.float32.FPushCommand;
-import org.jcnc.snow.vm.commands.stack.int32.IPushCommand;
-import org.jcnc.snow.vm.commands.stack.long64.LPushCommand;
-import org.jcnc.snow.vm.commands.stack.short16.SPushCommand;
-import org.jcnc.snow.vm.commands.vm.HaltCommand;
+import org.jcnc.snow.vm.commands.type.control.byte8.*;
+import org.jcnc.snow.vm.commands.type.control.double64.*;
+import org.jcnc.snow.vm.commands.type.control.float32.*;
+import org.jcnc.snow.vm.commands.type.control.int32.*;
+import org.jcnc.snow.vm.commands.type.control.long64.*;
+import org.jcnc.snow.vm.commands.type.control.short16.*;
+import org.jcnc.snow.vm.commands.type.control.byte8.BAndCommand;
+import org.jcnc.snow.vm.commands.type.control.byte8.BOrCommand;
+import org.jcnc.snow.vm.commands.type.control.byte8.BXorCommand;
+import org.jcnc.snow.vm.commands.type.control.int32.IAndCommand;
+import org.jcnc.snow.vm.commands.type.control.int32.IOrCommand;
+import org.jcnc.snow.vm.commands.type.control.int32.IXorCommand;
+import org.jcnc.snow.vm.commands.type.control.long64.LAndCommand;
+import org.jcnc.snow.vm.commands.type.control.long64.LOrCommand;
+import org.jcnc.snow.vm.commands.type.control.long64.LXorCommand;
+import org.jcnc.snow.vm.commands.type.control.short16.SAndCommand;
+import org.jcnc.snow.vm.commands.type.control.short16.SOrCommand;
+import org.jcnc.snow.vm.commands.type.control.short16.SXorCommand;
+import org.jcnc.snow.vm.commands.flow.control.JumpCommand;
+import org.jcnc.snow.vm.commands.flow.control.CallCommand;
+import org.jcnc.snow.vm.commands.flow.control.RetCommand;
+import org.jcnc.snow.vm.commands.register.control.MovCommand;
+import org.jcnc.snow.vm.commands.type.control.byte8.BLoadCommand;
+import org.jcnc.snow.vm.commands.type.control.byte8.BStoreCommand;
+import org.jcnc.snow.vm.commands.type.control.double64.DLoadCommand;
+import org.jcnc.snow.vm.commands.type.control.double64.DStoreCommand;
+import org.jcnc.snow.vm.commands.type.control.float32.FLoadCommand;
+import org.jcnc.snow.vm.commands.type.control.float32.FStoreCommand;
+import org.jcnc.snow.vm.commands.type.control.int32.ILoadCommand;
+import org.jcnc.snow.vm.commands.type.control.int32.IStoreCommand;
+import org.jcnc.snow.vm.commands.type.control.long64.LLoadCommand;
+import org.jcnc.snow.vm.commands.type.control.long64.LStoreCommand;
+import org.jcnc.snow.vm.commands.type.control.short16.SLoadCommand;
+import org.jcnc.snow.vm.commands.type.control.short16.SStoreCommand;
+import org.jcnc.snow.vm.commands.stack.control.DupCommand;
+import org.jcnc.snow.vm.commands.stack.control.PopCommand;
+import org.jcnc.snow.vm.commands.stack.control.SwapCommand;
+import org.jcnc.snow.vm.commands.type.control.byte8.BPushCommand;
+import org.jcnc.snow.vm.commands.type.control.double64.DPushCommand;
+import org.jcnc.snow.vm.commands.type.control.float32.FPushCommand;
+import org.jcnc.snow.vm.commands.type.control.int32.IPushCommand;
+import org.jcnc.snow.vm.commands.type.control.long64.LPushCommand;
+import org.jcnc.snow.vm.commands.type.control.short16.SPushCommand;
+import org.jcnc.snow.vm.commands.type.conversion.*;
+import org.jcnc.snow.vm.commands.system.control.HaltCommand;
 import org.jcnc.snow.vm.engine.VMOpCode;
+import org.jcnc.snow.vm.interfaces.Command;
 
 import java.util.Optional;
 
@@ -51,151 +56,204 @@ import java.util.Optional;
  * <p>This class uses an array for fast, constant-time access to corresponding command instances.</p>
  */
 public class CommandFactory {
-    private static final Command[] COMMANDS = new Command[1000]; // Adjust, according to your VMOpCode range
+    /** Complete command table. 0x0000 – 0x04FF (inclusive). */
+    private static final Command[] COMMANDS = new Command[0x0500];
 
     static {
-        // Initialize the array with corresponding commands based on opCode values
 
-        // 1   Arithmetic Operations (1–80)
-        // 1.1 int32 (1-10)
-        COMMANDS[VMOpCode.I_ADD] = new IAddCommand();      // 1
-        COMMANDS[VMOpCode.I_SUB] = new ISubCommand();      // 2
-        COMMANDS[VMOpCode.I_MUL] = new IMulCommand();      // 3
-        COMMANDS[VMOpCode.I_DIV] = new IDivCommand();      // 4
-        COMMANDS[VMOpCode.I_MOD] = new IModCommand();      // 5
-        COMMANDS[VMOpCode.I_INC] = new IIncCommand();      // 6
-        COMMANDS[VMOpCode.I_NEG] = new INegCommand();      // 7
-        // 1.2 long64 (11-20)
-        COMMANDS[VMOpCode.L_ADD] = new LAddCommand();      // 11
-        COMMANDS[VMOpCode.L_SUB] = new LSubCommand();      // 12
-        COMMANDS[VMOpCode.L_MUL] = new LMulCommand();      // 13
-        COMMANDS[VMOpCode.L_DIV] = new LDivCommand();      // 14
-        COMMANDS[VMOpCode.L_MOD] = new LModCommand();      // 15
-        COMMANDS[VMOpCode.L_INC] = new LIncCommand();      // 16
-        COMMANDS[VMOpCode.L_NEG] = new LNegCommand();      // 17
-        // 1.3 short16 (21-30)
-        COMMANDS[VMOpCode.S_ADD] = new SAddCommand();      // 21
-        COMMANDS[VMOpCode.S_SUB] = new SSubCommand();      // 22
-        COMMANDS[VMOpCode.S_MUL] = new SMulCommand();      // 23
-        COMMANDS[VMOpCode.S_DIV] = new SDivCommand();      // 24
-        COMMANDS[VMOpCode.S_MOD] = new SModCommand();      // 25
-        COMMANDS[VMOpCode.S_INC] = new SIncCommand();      // 26
-        COMMANDS[VMOpCode.S_NEG] = new SNegCommand();      // 27
-        // 1.4 byte8 (31-40)
-        COMMANDS[VMOpCode.B_ADD] = new BAddCommand();      // 31
-        COMMANDS[VMOpCode.B_SUB] = new BSubCommand();      // 32
-        COMMANDS[VMOpCode.B_MUL] = new BMulCommand();      // 33
-        COMMANDS[VMOpCode.B_DIV] = new BDivCommand();      // 34
-        COMMANDS[VMOpCode.B_MOD] = new BModCommand();      // 35
-        COMMANDS[VMOpCode.B_INC] = new BIncCommand();      // 36
-        COMMANDS[VMOpCode.B_NEG] = new BNegCommand();      // 37
-        // 1.5 double64 (41-50)
-        COMMANDS[VMOpCode.D_ADD] = new DAddCommand();      // 41
-        COMMANDS[VMOpCode.D_SUB] = new DSubCommand();      // 42
-        COMMANDS[VMOpCode.D_MUL] = new DMulCommand();      // 43
-        COMMANDS[VMOpCode.D_DIV] = new DDivCommand();      // 44
-        COMMANDS[VMOpCode.D_MOD] = new DModCommand();      // 45
-        COMMANDS[VMOpCode.D_INC] = new DIncCommand();      // 46
-        COMMANDS[VMOpCode.D_NEG] = new DNegCommand();      // 47
-        // 1.6 float32 (51-60)
-        COMMANDS[VMOpCode.F_ADD] = new FAddCommand();      // 51
-        COMMANDS[VMOpCode.F_SUB] = new FSubCommand();      // 52
-        COMMANDS[VMOpCode.F_MUL] = new FMulCommand();      // 53
-        COMMANDS[VMOpCode.F_DIV] = new FDivCommand();      // 54
-        COMMANDS[VMOpCode.F_MOD] = new FModCommand();      // 55
-        COMMANDS[VMOpCode.F_INC] = new FIncCommand();      // 56
-        COMMANDS[VMOpCode.F_NEG] = new FNegCommand();      // 57
+        // region Type Control (0x0000-0x00BF)
+        // region Byte8	 (0x0000-0x001F)
+        COMMANDS[VMOpCode.B_ADD]   = new BAddCommand();
+        COMMANDS[VMOpCode.B_SUB]   = new BSubCommand();
+        COMMANDS[VMOpCode.B_MUL]   = new BMulCommand();
+        COMMANDS[VMOpCode.B_DIV]   = new BDivCommand();
+        COMMANDS[VMOpCode.B_MOD]   = new BModCommand();
+        COMMANDS[VMOpCode.B_NEG]   = new BNegCommand();
+        COMMANDS[VMOpCode.B_INC]   = new BIncCommand();
 
-        // 1.7 Type Conversion (61-80)
-        COMMANDS[VMOpCode.I2L] = new I2LCommand();      // 61  int -> long
-        COMMANDS[VMOpCode.I2S] = new I2SCommand();      // 62  int -> short
-        COMMANDS[VMOpCode.I2B] = new I2BCommand();      // 63  int -> byte
-        COMMANDS[VMOpCode.I2D] = new I2DCommand();      // 64  int -> double
-        COMMANDS[VMOpCode.I2F] = new I2FCommand();      // 65  int -> float
+        COMMANDS[VMOpCode.B_AND]   = new BAndCommand();
+        COMMANDS[VMOpCode.B_OR]    = new BOrCommand();
+        COMMANDS[VMOpCode.B_XOR]   = new BXorCommand();
 
-        COMMANDS[VMOpCode.L2I] = new L2ICommand();      // 66  long -> int
-        COMMANDS[VMOpCode.L2D] = new L2DCommand();      // 67  long -> double
-        COMMANDS[VMOpCode.L2F] = new L2FCommand();      // 68  long -> float
+        COMMANDS[VMOpCode.B_PUSH]  = new BPushCommand();
+        COMMANDS[VMOpCode.B_LOAD]  = new BLoadCommand();
+        COMMANDS[VMOpCode.B_STORE] = new BStoreCommand();
 
-        COMMANDS[VMOpCode.F2I] = new F2ICommand();      // 69  float -> int
-        COMMANDS[VMOpCode.F2L] = new F2LCommand();      // 70  float -> long
-        COMMANDS[VMOpCode.F2D] = new F2DCommand();      // 71  float -> double
+        COMMANDS[VMOpCode.B_CE]    = new BCECommand();
+        COMMANDS[VMOpCode.B_CNE]   = new BCNECommand();
+        COMMANDS[VMOpCode.B_CG]    = new BCGCommand();
+        COMMANDS[VMOpCode.B_CGE]   = new BCGECommand();
+        COMMANDS[VMOpCode.B_CL]    = new BCLCommand();
+        COMMANDS[VMOpCode.B_CLE]   = new BCLECommand();
 
-        COMMANDS[VMOpCode.D2I] = new D2ICommand();      // 72  double -> int
-        COMMANDS[VMOpCode.D2L] = new D2LCommand();      // 73  double -> long
-        COMMANDS[VMOpCode.D2F] = new D2FCommand();      // 74  double -> float
+        // endregion
 
-        COMMANDS[VMOpCode.S2I] = new S2ICommand();      // 75  short -> int
+        // region Short16 (0x0020-0x003F)
+        COMMANDS[VMOpCode.S_ADD]   = new SAddCommand();
+        COMMANDS[VMOpCode.S_SUB]   = new SSubCommand();
+        COMMANDS[VMOpCode.S_MUL]   = new SMulCommand();
+        COMMANDS[VMOpCode.S_DIV]   = new SDivCommand();
+        COMMANDS[VMOpCode.S_MOD]   = new SModCommand();
+        COMMANDS[VMOpCode.S_NEG]   = new SNegCommand();
+        COMMANDS[VMOpCode.S_INC]   = new SIncCommand();
 
-        COMMANDS[VMOpCode.B2I] = new B2ICommand();      // 76  byte -> int
+        COMMANDS[VMOpCode.S_AND]   = new SAndCommand();
+        COMMANDS[VMOpCode.S_OR]    = new SOrCommand();
+        COMMANDS[VMOpCode.S_XOR]   = new SXorCommand();
 
-        // 1.8 Other (77-80)
+        COMMANDS[VMOpCode.S_PUSH]  = new SPushCommand();
+        COMMANDS[VMOpCode.S_LOAD]  = new SLoadCommand();
+        COMMANDS[VMOpCode.S_STORE] = new SStoreCommand();
 
-        // 2.  Bitwise Operations (81–90)
-        // 2.1 int32 (81-85)
-        COMMANDS[VMOpCode.I_AND] = new IAndCommand();      // 81
-        COMMANDS[VMOpCode.I_OR] = new IOrCommand();        // 82
-        COMMANDS[VMOpCode.I_XOR] = new IXorCommand();      // 83
-        // 2.2 Long64 (86-90)
-        COMMANDS[VMOpCode.L_AND] = new LAndCommand();      // 86
-        COMMANDS[VMOpCode.L_OR] = new LOrCommand();        // 87
-        COMMANDS[VMOpCode.L_XOR] = new LXorCommand();      // 88
+        COMMANDS[VMOpCode.S_CE]    = new SCECommand();
+        COMMANDS[VMOpCode.S_CNE]   = new SCNECommand();
+        COMMANDS[VMOpCode.S_CG]    = new SCGCommand();
+        COMMANDS[VMOpCode.S_CGE]   = new SCGECommand();
+        COMMANDS[VMOpCode.S_CL]    = new SCLCommand();
+        COMMANDS[VMOpCode.S_CLE]   = new SCLECommand();
+        // endregion
 
-        // 3. Control Flow Operations (91–110)
-        COMMANDS[VMOpCode.JUMP] = new JumpCommand();       // 91
-        COMMANDS[VMOpCode.IC_E] = new ICECommand();        // 92
-        COMMANDS[VMOpCode.IC_NE] = new ICNECommand();      // 93
-        COMMANDS[VMOpCode.IC_G] = new ICGCommand();        // 94
-        COMMANDS[VMOpCode.IC_GE] = new ICGECommand();      // 95
-        COMMANDS[VMOpCode.IC_L] = new ICLCommand();        // 96
-        COMMANDS[VMOpCode.IC_LE] = new ICLECommand();      // 97
+        // region Int32 (0x0040-0x005F)
+        COMMANDS[VMOpCode.I_ADD]   = new IAddCommand();
+        COMMANDS[VMOpCode.I_SUB]   = new ISubCommand();
+        COMMANDS[VMOpCode.I_MUL]   = new IMulCommand();
+        COMMANDS[VMOpCode.I_DIV]   = new IDivCommand();
+        COMMANDS[VMOpCode.I_MOD]   = new IModCommand();
+        COMMANDS[VMOpCode.I_NEG]   = new INegCommand();
+        COMMANDS[VMOpCode.I_INC]   = new IIncCommand();
 
-        // 4.  Stack Operations (111–150)
-        // 4.1 PUSH (111-120)
-        COMMANDS[VMOpCode.I_PUSH] = new IPushCommand();   // 111
-        COMMANDS[VMOpCode.L_PUSH] = new LPushCommand();   // 112
-        COMMANDS[VMOpCode.S_PUSH] = new SPushCommand();   // 113
-        COMMANDS[VMOpCode.B_PUSH] = new BPushCommand();   // 114
-        COMMANDS[VMOpCode.D_PUSH] = new DPushCommand();   // 115
-        COMMANDS[VMOpCode.F_PUSH] = new FPushCommand();   // 116
-        // 4.2 POP (121-125)
-        COMMANDS[VMOpCode.POP] = new PopCommand();        // 121
-        // 4.3 DUP (126-130)
-        COMMANDS[VMOpCode.DUP] = new DupCommand();        // 126
-        // 4.4 SWAP (131-135)
-        COMMANDS[VMOpCode.SWAP] = new SwapCommand();      // 131
+        COMMANDS[VMOpCode.I_AND]   = new IAndCommand();
+        COMMANDS[VMOpCode.I_OR]    = new IOrCommand();
+        COMMANDS[VMOpCode.I_XOR]   = new IXorCommand();
 
-        // 4.5 Other (136-150)
+        COMMANDS[VMOpCode.I_PUSH]  = new IPushCommand();
+        COMMANDS[VMOpCode.I_LOAD]  = new ILoadCommand();
+        COMMANDS[VMOpCode.I_STORE] = new IStoreCommand();
 
-        // 5.  Memory Operations (151–200)
-        // 5.1 STORE (151-160)
-        COMMANDS[VMOpCode.I_STORE] = new IStoreCommand();   // 151
-        COMMANDS[VMOpCode.L_STORE] = new LStoreCommand();   // 152
-        COMMANDS[VMOpCode.S_STORE] = new SStoreCommand();   // 153
-        COMMANDS[VMOpCode.B_STORE] = new BStoreCommand();   // 154
-        COMMANDS[VMOpCode.D_STORE] = new DStoreCommand();   // 155
-        COMMANDS[VMOpCode.F_STORE] = new FStoreCommand();   // 156
-        // 5.2 LOAD (161-170)
-        COMMANDS[VMOpCode.I_LOAD] = new ILoadCommand();     // 161
-        COMMANDS[VMOpCode.L_LOAD] = new LLoadCommand();     // 162
-        COMMANDS[VMOpCode.S_LOAD] = new SLoadCommand();     // 163
-        COMMANDS[VMOpCode.B_LOAD] = new BLoadCommand();     // 164
-        COMMANDS[VMOpCode.D_LOAD] = new DLoadCommand();     // 165
-        COMMANDS[VMOpCode.F_LOAD] = new FLoadCommand();     // 166
+        COMMANDS[VMOpCode.I_CE]    = new ICECommand();
+        COMMANDS[VMOpCode.I_CNE]   = new ICNECommand();
+        COMMANDS[VMOpCode.I_CG]    = new ICGCommand();
+        COMMANDS[VMOpCode.I_CGE]   = new ICGECommand();
+        COMMANDS[VMOpCode.I_CL]    = new ICLCommand();
+        COMMANDS[VMOpCode.I_CLE]   = new ICLECommand();
+        // endregion
 
-        // 5.3 MOV (171-176)
-        COMMANDS[VMOpCode.MOV] = new MovCommand();          // 171
+        // region Long64 (0x0060-0x007F)
+        COMMANDS[VMOpCode.L_ADD]   = new LAddCommand();
+        COMMANDS[VMOpCode.L_SUB]   = new LSubCommand();
+        COMMANDS[VMOpCode.L_MUL]   = new LMulCommand();
+        COMMANDS[VMOpCode.L_DIV]   = new LDivCommand();
+        COMMANDS[VMOpCode.L_MOD]   = new LModCommand();
+        COMMANDS[VMOpCode.L_NEG]   = new LNegCommand();
+        COMMANDS[VMOpCode.L_INC]   = new LIncCommand();
 
-        // 5.4 Other (176-200)
+        COMMANDS[VMOpCode.L_AND]   = new LAndCommand();
+        COMMANDS[VMOpCode.L_OR]    = new LOrCommand();
+        COMMANDS[VMOpCode.L_XOR]   = new LXorCommand();
 
-        // 6. Function Operations (201–205)
-        COMMANDS[VMOpCode.CALL] = new CallCommand();        // 201
-        COMMANDS[VMOpCode.RET] = new RetCommand();          // 202
+        COMMANDS[VMOpCode.L_PUSH]  = new LPushCommand();
+        COMMANDS[VMOpCode.L_LOAD]  = new LLoadCommand();
+        COMMANDS[VMOpCode.L_STORE] = new LStoreCommand();
+
+        COMMANDS[VMOpCode.L_CE]    = new LCECommand();
+        COMMANDS[VMOpCode.L_CNE]   = new LCNECommand();
+        COMMANDS[VMOpCode.L_CG]    = new LCGCommand();
+        COMMANDS[VMOpCode.L_CGE]   = new LCGECommand();
+        COMMANDS[VMOpCode.L_CL]    = new LCLCommand();
+        COMMANDS[VMOpCode.L_CLE]   = new LCLECommand();
+        // endregion
+
+        // region Float32 (0x0080-0x009F)
+        COMMANDS[VMOpCode.F_ADD]   = new FAddCommand();
+        COMMANDS[VMOpCode.F_SUB]   = new FSubCommand();
+        COMMANDS[VMOpCode.F_MUL]   = new FMulCommand();
+        COMMANDS[VMOpCode.F_DIV]   = new FDivCommand();
+        COMMANDS[VMOpCode.F_MOD]   = new FModCommand();
+        COMMANDS[VMOpCode.F_NEG]   = new FNegCommand();
+        COMMANDS[VMOpCode.F_INC]   = new FIncCommand();
+
+        COMMANDS[VMOpCode.F_PUSH]  = new FPushCommand();
+        COMMANDS[VMOpCode.F_LOAD]  = new FLoadCommand();
+        COMMANDS[VMOpCode.F_STORE] = new FStoreCommand();
+
+        COMMANDS[VMOpCode.F_CE]    = new FCECommand();
+        COMMANDS[VMOpCode.F_CNE]   = new FCNECommand();
+        COMMANDS[VMOpCode.F_CG]    = new FCGCommand();
+        COMMANDS[VMOpCode.F_CGE]   = new FCGECommand();
+        COMMANDS[VMOpCode.F_CL]    = new FCLCommand();
+        COMMANDS[VMOpCode.F_CLE]   = new FCLECommand();
+        // endregion
+
+        // region Double64 (0x00A0-0x00BF)
+        COMMANDS[VMOpCode.D_ADD]   = new DAddCommand();
+        COMMANDS[VMOpCode.D_SUB]   = new DSubCommand();
+        COMMANDS[VMOpCode.D_MUL]   = new DMulCommand();
+        COMMANDS[VMOpCode.D_DIV]   = new DDivCommand();
+        COMMANDS[VMOpCode.D_MOD]   = new DModCommand();
+        COMMANDS[VMOpCode.D_NEG]   = new DNegCommand();
+        COMMANDS[VMOpCode.D_INC]   = new DIncCommand();
+
+        COMMANDS[VMOpCode.D_PUSH]  = new DPushCommand();
+        COMMANDS[VMOpCode.D_LOAD]  = new DLoadCommand();
+        COMMANDS[VMOpCode.D_STORE] = new DStoreCommand();
+
+        COMMANDS[VMOpCode.D_CE]    = new DCECommand();
+        COMMANDS[VMOpCode.D_CNE]   = new DCNECommand();
+        COMMANDS[VMOpCode.D_CG]    = new DCGCommand();
+        COMMANDS[VMOpCode.D_CGE]   = new DCGECommand();
+        COMMANDS[VMOpCode.D_CL]    = new DCLCommand();
+        COMMANDS[VMOpCode.D_CLE]   = new DCLECommand();
+        // endregion
+        // endregion
+
+        // region Type Conversion (0x00C0-0x00DF)
+        COMMANDS[VMOpCode.I2L] = new I2LCommand();
+        COMMANDS[VMOpCode.I2S] = new I2SCommand();
+        COMMANDS[VMOpCode.I2B] = new I2BCommand();
+        COMMANDS[VMOpCode.I2D] = new I2DCommand();
+        COMMANDS[VMOpCode.I2F] = new I2FCommand();
+
+        COMMANDS[VMOpCode.L2I] = new L2ICommand();
+        COMMANDS[VMOpCode.L2D] = new L2DCommand();
+        COMMANDS[VMOpCode.L2F] = new L2FCommand();
+
+        COMMANDS[VMOpCode.F2I] = new F2ICommand();
+        COMMANDS[VMOpCode.F2L] = new F2LCommand();
+        COMMANDS[VMOpCode.F2D] = new F2DCommand();
+
+        COMMANDS[VMOpCode.D2I] = new D2ICommand();
+        COMMANDS[VMOpCode.D2L] = new D2LCommand();
+        COMMANDS[VMOpCode.D2F] = new D2FCommand();
+
+        COMMANDS[VMOpCode.S2I] = new S2ICommand();
+        COMMANDS[VMOpCode.B2I] = new B2ICommand();
+        // endregion
+
+        // region Stack Control (0x0100-0x01FF)
+        COMMANDS[VMOpCode.POP]  = new PopCommand();
+        COMMANDS[VMOpCode.DUP]  = new DupCommand();
+        COMMANDS[VMOpCode.SWAP] = new SwapCommand();
+        // endregion
+
+        // region Flow Control (0x0200-0x02FF)
+        COMMANDS[VMOpCode.JUMP] = new JumpCommand();
+        COMMANDS[VMOpCode.CALL] = new CallCommand();
+        COMMANDS[VMOpCode.RET]  = new RetCommand();
+        // endregion
+
+        // region Register Control (0x0300-0x03FF)
+        COMMANDS[VMOpCode.MOV]  = new MovCommand();
+        // endregion
+
+        // region  System Control (0x0400-0x04FF)
+        COMMANDS[VMOpCode.HALT]        = new HaltCommand();
+//        COMMANDS[VMOpCode.SYSCALL]     = new SyscallCommand();
+//        COMMANDS[VMOpCode.DEBUG_TRAP]  = new DebugTrapCommand();
+        // endregion
 
-        // 7. Virtual Machine Operations(241-255)
-        COMMANDS[VMOpCode.HALT] = new HaltCommand();        // 255
     }
 
+
     /**
      * Default constructor for creating an instance of CommandFactory.
      * This constructor is empty as no specific initialization is required.
diff --git a/src/main/resources/version.properties b/src/main/resources/version.properties
new file mode 100644
index 0000000..bdb6c2f
--- /dev/null
+++ b/src/main/resources/version.properties
@@ -0,0 +1 @@
+snow.version=${project.version}