Upload 134 files

.dockerignore

@@ -0,0 +1,6 @@
+build
+.gradle
+.idea
+Dockerfile
+README.md
+.gitignore

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+linuxfile/libc.so filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,10 @@
+**/build/
+.idea
+.gradle
+
+run/
+**/debug-sandbox/
+/testbot
+/tencent/src/main/java/tencentlibfekit/BasePath.java
+
+hs_*.log

BasePath.java

@@ -0,0 +1,15 @@
+package tencentlibfekit;
+
+public class BasePath {
+    public static final String PROJECT_DIR = "";
+    static long BOT_ACCOUNT = 0L;
+    static String BOT_PASSWORD = "";
+
+    public static String STRUCT_DEF = "";
+    public static String SO = "";
+    public static String VMTS = "";
+
+    public static String APK_PATH = "";
+
+    public static String userDataPath = "";
+}

Dockerfile

@@ -0,0 +1,29 @@
+FROM openjdk:18-bullseye AS builder
+
+ADD ./ /build
+ADD ./BasePath.java /build/tencent/src/main/java/tencentlibfekit/
+WORKDIR /build
+RUN chmod +x ./gradlew
+RUN ./gradlew --no-daemon
+RUN ./gradlew --no-daemon :packer:build
+
+
+FROM openjdk:18-bullseye
+RUN mkdir /app
+WORKDIR /app
+COPY --from=builder /build/packer/build/proguard/server-remap.jar /app/server.jar
+
+# 允许使用 docker cp 获取 console 插件
+COPY --from=builder /build/packer/build/proguard/vivo50-kfc-code45-rpc.jar /app
+
+ENV SERVER_IDENTITY_KEY=vivo50
+ENV AUTH_KEY=kfc
+# 因为兼容性原因改成host和port
+ENV HOST=0.0.0.0
+ENV PORT=8888
+
+EXPOSE 8888
+
+CMD java -jar /app/server.jar
+
+

LICENSE

@@ -0,0 +1,11 @@
+DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+
+Version 2, December 2004
+
+Copyright (C) 2004 Kilio Kuara
+
+Everyone is permitted to copy and distribute verbatim or modified copies of this license document, and changing it is allowed as long as the name is changed.
+
+DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. You just DO WHAT THE FUCK YOU WANT TO.

build.gradle

@@ -0,0 +1,42 @@
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.guardsquare:proguard-gradle:7.3.2'
+    }
+}
+
+plugins {
+    id 'java'
+    id 'java-library'
+}
+
+repositories {
+    mavenCentral()
+}
+
+
+dependencies {
+    api 'io.github.karlatemp:unsafe-accessor:1.7.0'
+    api 'org.ow2.asm:asm-util:9.5'
+    api 'org.ow2.asm:asm-tree:9.5'
+    api 'org.ow2.asm:asm-commons:9.5'
+
+    api 'org.jetbrains:annotations:23.0.0'
+
+    api 'org.apache.commons:commons-jexl3:3.2.1'
+
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.2'
+    testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.9.2'
+
+    api('com.github.zhkl0228:unidbg-android:0.9.7') {
+        exclude group: 'com.github.zhkl0228', module: 'unicorn'
+    }
+    api 'com.github.zhkl0228:unidbg-unicorn2:0.9.7'
+
+}
+
+test {
+    useJUnitPlatform()
+}

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.6-bin.zip
+networkTimeout=10000
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,244 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045 
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045 
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,92 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

linuxfile/libc.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e997495cab761b24e59cf7b8ca4a4f1bc580b990ec669d954239e91843aec6a8
+size 1084084

packer/build.gradle

@@ -0,0 +1,288 @@
+import proguard.gradle.ProGuardTask
+
+plugins {
+    id 'java'
+    id 'java-library'
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    api rootProject
+}
+
+public abstract class OurJavaExec extends JavaExec {
+    @Input
+    abstract Property<FileCollection> getOurInput()
+}
+
+TaskProvider<OurJavaExec> createHelperTask(String taskName, String taskType, String fileExt) {
+    return createHelperTask(taskName, taskType, fileExt, null)
+}
+
+TaskProvider<OurJavaExec> createHelperTask(String taskName, String taskType, String fileExt, File outFile) {
+    def doDebug = false
+
+    def rsp = tasks.register(taskName, OurJavaExec.class)
+    rsp.configure { exec ->
+        exec.group = 'package'
+        File finalOutFile
+        if (outFile == null) {
+            finalOutFile = new File(exec.temporaryDir, "result." + fileExt)
+        } else {
+            finalOutFile = outFile
+        }
+        exec.outputs.file(finalOutFile)
+
+        def runtime = sourceSets.main.runtimeClasspath
+        exec.inputs.property('runtime', runtime)
+
+        exec.mainClass.set('packer.HelperTask')
+        exec.classpath = runtime
+        exec.dependsOn(exec.ourInput)
+
+        exec.doFirst {
+            def inputs = exec.ourInput
+            def inputFile = inputs.get().singleFile
+
+            exec.args(taskType, inputFile.absolutePath, finalOutFile.absolutePath)
+            exec.temporaryDir.mkdirs()
+            finalOutFile.parentFile?.mkdirs()
+            exec.workingDir(exec.temporaryDir)
+            exec.environment("PACKER_DEBUG", doDebug.toString())
+        }
+
+    }
+    return rsp
+}
+
+def stuDefine = project(':struct-define')
+def tencent = project(':tencent')
+def projThis = project
+
+tasks.jar.enabled = false
+
+def transformClassStub = createHelperTask("transformClassStub", "StubTransform", "jar")
+
+def packResources = tasks.register('packResources', Zip.class) { task ->
+    task.group = 'package'
+    task.from(rootProject.file('linuxfile')) { into 'linuxfile' }
+
+    task.archiveBaseName.set('resources')
+    task.destinationDir(task.temporaryDir)
+}
+
+def packServiceLoader = createHelperTask("packServiceLoader", "PackServiceLoader", "jar")
+packServiceLoader.configure { exec ->
+    exec.ourInput.set(packResources.get().outputs.files)
+}
+
+def packRpcServiceLoader = createHelperTask("packRpcServiceLoader", "ConvertToRpc", "jar")
+packRpcServiceLoader.configure { exec ->
+    exec.ourInput.set(packServiceLoader.get().outputs.files)
+}
+
+
+def packConsoleJar = tasks.register('packConsoleJar', Jar.class) { task ->
+    task.group = 'package'
+
+    task.from(packResources) { into 'kfc/vivo50/code45'; rename { 'resources.zip' } }
+
+
+    task.archiveBaseName.set('vivo50-kfc-code45')
+}
+
+def packConsoleRpc = tasks.register('packConsoleRpc', Jar.class) { task ->
+
+    task.from(rootProject.file('tencent/src/main/rpcResources')) { CopySpec spec ->
+        spec.duplicatesStrategy(DuplicatesStrategy.INCLUDE)
+    }
+
+    task.inputs.files(packConsoleJar.get().outputs)
+    task.from(zipTree(packConsoleJar.get().outputs.files.singleFile)) {
+        exclude 'kfc/vivo50/code45/ServiceSelector.class'
+        exclude 'kfc/vivo50/code45/resources.zip'
+        duplicatesStrategy(DuplicatesStrategy.EXCLUDE)
+    }
+
+    task.inputs.files(packRpcServiceLoader.get().outputs)
+    task.from(zipTree(packRpcServiceLoader.get().outputs.files.singleFile))
+
+    task.archiveBaseName.set('vivo50-kfc-code45-rpc')
+}
+
+def packServer = tasks.register('packServer', Jar.class) { task ->
+    task.group = 'package'
+
+    task.archiveBaseName.set('server')
+
+    task.manifest.attributes([
+            'Main-Class': 'tencentlibfekit.vmservice.rpc.RpcServerBootstrap',
+    ])
+}
+
+def remapServerJar = createHelperTask("remapServerJar", "SimpleRemapper", "jar", file('build/proguard/server-remap.jar'))
+
+
+projThis.tasks.named('build').configure { it.finalizedBy(':packer:packConsoleJar') }
+projThis.tasks.named('build').configure { it.finalizedBy(':packer:packConsoleRpc') }
+projThis.tasks.named('build').configure { it.finalizedBy(':packer:packServer') }
+projThis.tasks.named('build').configure { it.finalizedBy(':packer:remapServerJar') }
+
+
+stuDefine.afterEvaluate {
+    transformClassStub.configure { exec ->
+        exec.ourInput.set(stuDefine.tasks.getByName('jar').outputs.files)
+    }
+}
+
+tencent.afterEvaluate {
+    def packTencent = { Jar pack ->
+        pack.inputs.files(tencent.tasks.jar.outputs)
+        pack.from(zipTree(tencent.tasks.jar.outputs.files.singleFile)) {
+            exclude 'kfc/vivo50/code45/ServiceSelector.class'
+            exclude 'kfc/vivo50/code45/StubClasses.class'
+        }
+
+        pack.inputs.files(transformClassStub.get().outputs)
+        pack.from(zipTree(transformClassStub.get().outputs.files.singleFile))
+
+        pack.inputs.files(packServiceLoader.get().outputs)
+        pack.from(zipTree(packServiceLoader.get().outputs.files.singleFile))
+    }
+
+    packConsoleJar.configure { packTencent(it) }
+
+    packServer.configure { pack ->
+        pack.inputs.files(packConsoleJar.get().outputs)
+        pack.from(zipTree(packConsoleJar.get().outputs.files.singleFile)) {
+            exclude 'META-INF/mirai-console-plugin/**'
+            exclude 'META-INF/services/net.mamoe.mirai.console.*'
+            exclude 'com/kiliokuara/kuimivm/**'
+        }
+
+        tencent.configurations.runtimeClasspath.files.each { sfile ->
+            var pt = sfile.absolutePath
+            if (pt.contains('mirai-core')) return
+
+            if (sfile.isDirectory()) {
+                pack.from(sfile)
+            } else {
+                pack.from(zipTree(sfile)) {
+                    exclude 'module-info.class'
+                    exclude 'META-INF/versions/9/module-info.class'
+                    exclude 'META-INF/*'
+                }
+            }
+        }
+    }
+
+
+    // proguard
+
+    projThis.tasks.register('buildConsoleRpc', ProGuardTask.class) { pg ->
+        pg.group = 'proguard'
+
+        pg.injars(packConsoleRpc.get().outputs)
+        pg.inputs.files(packConsoleRpc.get().outputs)
+        pg.inputs.files(tencent.configurations.compileClasspath)
+
+        tencent.configurations.compileClasspath.files.each { cp ->
+            if (cp == projThis.file('src/main/resources')) return
+
+            pg.libraryjars(cp)
+        }
+
+        pg.libraryjars "${System.getProperty('java.home')}/jmods/java.base.jmod"
+        pg.libraryjars "${System.getProperty('java.home')}/jmods/java.net.http.jmod"
+
+        pg.verbose()
+        pg.outjars(new File(projThis.buildDir, 'proguard/vivo50-kfc-code45-rpc.jar'))
+        pg.dontwarn()
+        pg.forceprocessing()
+        pg.optimizations('*')
+        pg.optimizationpasses(5)
+
+        pg.keep('class * extends net.mamoe.mirai.console.plugin.jvm.JavaPlugin { static ** INSTANCE; }')
+
+        pg.keepattributes('InnerClasses,Signature,RuntimeVisible*Annotations,EnclosingMethod,*Annotation*')
+    }
+    projThis.tasks.named('build').configure { it.finalizedBy(':packer:buildConsoleRpc') }
+
+
+    def buildServer = projThis.tasks.register('buildServer', ProGuardTask.class) { pg ->
+        pg.group = 'proguard'
+
+        pg.injars(packServer.get().outputs)
+        pg.inputs.files(packServer.get().outputs)
+        pg.inputs.files(tencent.configurations.compileClasspath)
+
+//        tencent.configurations.compileClasspath.files.each { cp ->
+//            if (cp == projThis.file('src/main/resources')) return
+//
+//            pg.libraryjars(cp)
+//        }
+
+        pg.libraryjars "${System.getProperty('java.home')}/jmods/java.base.jmod"
+        pg.libraryjars "${System.getProperty('java.home')}/jmods/java.net.http.jmod"
+        pg.libraryjars "${System.getProperty('java.home')}/jmods/java.desktop.jmod"
+
+        // pg.verbose()
+        pg.outjars(new File(projThis.buildDir, 'proguard/server.jar'))
+        pg.outputs.file(new File(projThis.buildDir, 'proguard/server.jar'))
+
+        pg.dontwarn()
+        pg.dontnote()
+
+        pg.forceprocessing()
+        pg.optimizations('*')
+        pg.optimizationpasses(1)
+
+        pg.keepclasseswithmembers('class **.RpcServerBootstrap { public static void main(java.lang.String[]); }')
+
+        pg.keep('class io.netty.** { *; }')
+        pg.keep('class io.vertx.** { *; }')
+
+        pg.keep('class io.github.karlatemp.unsafeaccessor.** { *; }')
+        pg.keep('class com.sun.jna.** { *; }')
+
+        pg.keep('class com.google.** { *; }')
+        pg.keep('class com.fasterxml.jackson.** { *; }')
+        pg.keepclassmembers('class * { @**.SerializedName <fields>; }')
+
+        pg.keep('class org.apache.** { *; }')
+        pg.keep('class org.slf4j.** { *; }')
+
+        pg.keep('class com.github.unidbg.** { *; }')
+        pg.keep('class com.github.zhkl0228.** { *; }')
+        pg.keep('class de.fearlesstobi.** { *; }')
+        pg.keep('class unicorn.** { *; }')
+        pg.keep('class keystone.** { *; }')
+
+
+        pg.keep('class com.kiliokuara.kuimivm.** { *; }') // stupid ProGuard
+        pg.keepclassmembers('class * { static void initialize(**.KuimiVM,**.KuimiObject); }')
+        pg.keepclassmembers('class * extends com.kiliokuara.kuimivm.KuimiMethod { <methods>; }')
+
+        pg.keep allowobfuscation: true, 'class android.** { *; }'
+        pg.keep allowobfuscation: true, 'class com.tencent.mobileqq.** { *; }'
+
+
+        pg.keepattributes('Signature,RuntimeVisible*Annotations,EnclosingMethod,*Annotation*')
+        pg.flattenpackagehierarchy('kfc')
+    }
+    remapServerJar.configure { exec ->
+        exec.ourInput.set(buildServer.get().outputs.files)
+    }
+
+
+    projThis.tasks.named('build').configure { it.finalizedBy(':packer:buildServer') }
+}
+
+packConsoleJar.configure { pack ->
+    pack.inputs.files(rootProject.tasks.jar.outputs)
+    pack.from(zipTree(rootProject.tasks.jar.outputs.files.singleFile))
+}
+

packer/src/main/java/packer/HelperTask.java

@@ -0,0 +1,78 @@
+package packer;
+
+import io.github.karlatemp.unsafeaccessor.Root;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+
+import java.io.*;
+import java.lang.invoke.MethodType;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+import java.util.zip.ZipOutputStream;
+
+public class HelperTask {
+    public static void classInit(ClassWriter cw) {
+        var init = cw.visitMethod(Opcodes.ACC_PRIVATE, "<init>", "()V", null, null);
+        init.visitVarInsn(Opcodes.ALOAD, 0);
+        init.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+        init.visitInsn(Opcodes.RETURN);
+        init.visitMaxs(3, 1);
+    }
+
+    public static void main(String[] args) throws Throwable {
+        var taskName = args[0];
+        var input = args[1];
+        var output = args[2];
+
+
+        var taskClass = Class.forName("packer.tasks." + taskName);
+
+        Root.getTrusted(taskClass).findStatic(
+                taskClass, "process", MethodType.methodType(void.class, String.class, String.class)
+        ).invoke(input, output);
+    }
+
+    public static Map<String, byte[]> loadZip(File file) throws IOException {
+        var rsp = new HashMap<String, byte[]>();
+        try (var zipInput = new ZipInputStream(new BufferedInputStream(new FileInputStream(file), 20480))) {
+            while (true) {
+                var entry = zipInput.getNextEntry();
+                if (entry == null) break;
+                if (entry.isDirectory()) continue;
+                rsp.put(entry.getName(), zipInput.readAllBytes());
+            }
+        }
+        return rsp;
+    }
+
+    public static void writeZip(OutputStream outputStream, Map<String, byte[]> zip) throws IOException {
+        var zos = new ZipOutputStream(new BufferedOutputStream(outputStream, 20480));
+
+        for (var entry : zip.entrySet()) {
+            zos.putNextEntry(new ZipEntry(entry.getKey()));
+            zos.write(entry.getValue());
+        }
+
+        zos.finish();
+        zos.flush();
+    }
+
+    public static String gitCommitHash() {
+        try {
+            var process = new ProcessBuilder("git", "rev-parse", "HEAD")
+                    .redirectError(ProcessBuilder.Redirect.INHERIT)
+                    .start();
+            process.getOutputStream().close();
+            try (var is = process.getInputStream()) {
+                return new String(is.readAllBytes()).trim();
+            } finally {
+                process.waitFor();
+                process.destroy();
+            }
+        } catch (Throwable throwable) {
+            throw new RuntimeException(throwable);
+        }
+    }
+}

packer/src/main/java/packer/tasks/ConvertToRpc.java

@@ -0,0 +1,42 @@
+package packer.tasks;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.ClassNode;
+import packer.HelperTask;
+
+import java.io.File;
+import java.io.FileOutputStream;
+
+public class ConvertToRpc {
+    public static void process(String input, String output) throws Throwable {
+        var zip = HelperTask.loadZip(new File(input));
+
+        var cnnode = new ClassNode();
+        new ClassReader(zip.get("kfc/vivo50/code45/ServiceSelector.class")).accept(cnnode, 0);
+
+        {
+            for (var met : cnnode.methods) {
+                if (met.name.equals("doRpc")) {
+                    met.instructions.clear();
+                    met.visitInsn(Opcodes.ICONST_1);
+                    met.visitInsn(Opcodes.IRETURN);
+                }
+                if (met.name.equals("get")) {
+                    met.instructions.clear();
+                    met.visitInsn(Opcodes.ACONST_NULL);
+                    met.visitInsn(Opcodes.ARETURN);
+                }
+            }
+
+            var cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+            cnnode.accept(cw);
+            zip.put("kfc/vivo50/code45/ServiceSelector.class", cw.toByteArray());
+        }
+
+        try (var out = new FileOutputStream(output)) {
+            HelperTask.writeZip(out, zip);
+        }
+    }
+}

packer/src/main/java/packer/tasks/PackServiceLoader.java

@@ -0,0 +1,99 @@
+package packer.tasks;
+
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import packer.HelperTask;
+
+import java.io.BufferedOutputStream;
+import java.io.FileOutputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.security.MessageDigest;
+import java.util.HexFormat;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+public class PackServiceLoader {
+    public static void process(String input, String output) throws Throwable {
+        System.out.println(input);
+
+        try (var zipOutput = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(output)))) {
+            zipOutput.putNextEntry(new ZipEntry("kfc/vivo50/code45/ServiceSelector.class"));
+
+            var cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+            cw.visit(Opcodes.V11, Opcodes.ACC_PUBLIC, "kfc/vivo50/code45/ServiceSelector", null, "java/lang/Object", null);
+
+            HelperTask.classInit(cw);
+
+            {
+                var mv = cw.visitMethod(Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, "mainClass", "()Ljava/lang/String;", null, null);
+                mv.visitLdcInsn(Type.getObjectType("libvtx/VGenerated"));
+                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Class", "getName", "()Ljava/lang/String;", false);
+                mv.visitInsn(Opcodes.ARETURN);
+                mv.visitMaxs(0, 0);
+            }
+
+            {
+                var mv = cw.visitMethod(Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, "resourceSha1", "()Ljava/lang/String;", null, null);
+
+                mv.visitLdcInsn(HexFormat.of().formatHex(
+                        MessageDigest.getInstance("sha1").digest(
+                                Files.readAllBytes(Path.of(input))
+                        )
+                ));
+
+                mv.visitInsn(Opcodes.ARETURN);
+                mv.visitMaxs(0, 0);
+            }
+
+            {
+                var mv = cw.visitMethod(Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, "commitHash", "()Ljava/lang/String;", null, null);
+
+                mv.visitLdcInsn(HelperTask.gitCommitHash());
+
+                mv.visitInsn(Opcodes.ARETURN);
+                mv.visitMaxs(0, 0);
+            }
+
+            {
+                var mv = cw.visitMethod(Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, "buildTime", "()J", null, null);
+
+                mv.visitLdcInsn(System.currentTimeMillis());
+
+                mv.visitInsn(Opcodes.LRETURN);
+                mv.visitMaxs(0, 0);
+            }
+
+            {
+                var mv = cw.visitMethod(Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, "isLocal", "()Z", null, null);
+
+                mv.visitInsn(Opcodes.ICONST_0);
+
+                mv.visitInsn(Opcodes.IRETURN);
+                mv.visitMaxs(0, 0);
+            }
+            {
+                var mv = cw.visitMethod(Opcodes.ACC_STATIC, "doRpc", "()Z", null, null);
+
+                mv.visitInsn(Opcodes.ICONST_0);
+
+                mv.visitInsn(Opcodes.IRETURN);
+                mv.visitMaxs(0, 0);
+            }
+
+            {
+                var mv = cw.visitMethod(Opcodes.ACC_STATIC, "get", "(Ljava/io/File;Ljava/io/File;)Lkfc/vivo50/code45/ConsoleServiceFactory;", null, null);
+                mv.visitTypeInsn(Opcodes.NEW, "kfc/vivo50/code45/ConsoleServiceFactory$Packed");
+                mv.visitInsn(Opcodes.DUP);
+                mv.visitVarInsn(Opcodes.ALOAD, 0);
+                mv.visitVarInsn(Opcodes.ALOAD, 1);
+                mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "kfc/vivo50/code45/ConsoleServiceFactory$Packed", "<init>", "(Ljava/io/File;Ljava/io/File;)V", false);
+                mv.visitInsn(Opcodes.ARETURN);
+                mv.visitMaxs(0, 0);
+            }
+
+            zipOutput.write(cw.toByteArray());
+        }
+    }
+}

packer/src/main/java/packer/tasks/SimpleRemapper.java

@@ -0,0 +1,97 @@
+package packer.tasks;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.commons.ClassRemapper;
+import org.objectweb.asm.commons.Remapper;
+import org.objectweb.asm.tree.ClassNode;
+import packer.HelperTask;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.util.*;
+
+public class SimpleRemapper {
+    public static void process(String input, String output) throws Throwable {
+        var zip = HelperTask.loadZip(new File(input));
+
+        var processPackages = List.of(
+                "kfc/",
+                "com/kiliokuara/kuimivm/"
+        );
+
+        var classes = new HashMap<String, ClassNode>();
+        var remapTable = new HashMap<String, String>();
+        var toolkit = new Object() {
+            private final Set<String> usedNames = new HashSet<>();
+
+            String nextName() {
+                while (true) {
+                    var newName = "n" + UUID.randomUUID().toString().replace("-", "");
+                    if (usedNames.add(newName)) return newName;
+                }
+            }
+
+            boolean needRemap(String classname) {
+                for (var pkg : processPackages) {
+                    if (classname.startsWith(pkg)) return true;
+                }
+                return false;
+            }
+
+            String getPackage(String cname) {
+                var lastIdx = cname.lastIndexOf('/');
+                return cname.substring(0, lastIdx);
+            }
+        };
+
+        zip.entrySet().removeIf(entry -> {
+            if (entry.getKey().endsWith(".class")) {
+                var cnode = new ClassNode();
+                new ClassReader(entry.getValue()).accept(cnode, 0);
+                classes.put(cnode.name, cnode);
+                return true;
+            }
+            return false;
+        });
+
+        var pkgRemap = new HashMap<String, String>();
+
+        for (var klass : classes.values()) {
+            if (!toolkit.needRemap(klass.name)) continue;
+
+            var pkg = toolkit.getPackage(klass.name);
+            pkgRemap.computeIfAbsent(pkg, $ -> "kfc/" + toolkit.nextName());
+        }
+
+
+        for (var klass : classes.values()) {
+            if (!toolkit.needRemap(klass.name)) continue;
+            var pkg = toolkit.getPackage(klass.name);
+
+            var rname = pkgRemap.get(pkg) + '/' + toolkit.nextName();
+            remapTable.put(klass.name, rname);
+        }
+
+        var remapper = new Remapper() {
+            @Override
+            public String map(String internalName) {
+                return remapTable.getOrDefault(internalName, internalName);
+            }
+        };
+
+        for (var klass : classes.values()) {
+            var newKlass = new ClassNode();
+            klass.accept(new ClassRemapper(newKlass, remapper));
+
+            var cw = new ClassWriter(0);
+            newKlass.accept(cw);
+
+            zip.put(newKlass.name + ".class", cw.toByteArray());
+        }
+
+        try (var out = new FileOutputStream(output)) {
+            HelperTask.writeZip(out, zip);
+        }
+    }
+}

packer/src/main/java/packer/tasks/StubTransform.java

@@ -0,0 +1,63 @@
+package packer.tasks;
+
+import com.kiliokuara.kuimivm.transform.JarTransformer;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import packer.HelperTask;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+import java.util.zip.ZipOutputStream;
+
+public class StubTransform {
+    public static void process(String input, String output) throws Throwable {
+        var transform = new JarTransformer();
+        transform.setDebug(Boolean.parseBoolean(System.getenv("PACKER_DEBUG")));
+        System.out.println("SRFC: " + input);
+
+        try (var zip = new ZipInputStream(new BufferedInputStream(new FileInputStream(input), 20480))) {
+            transform.loadFrom(zip);
+        }
+        transform.generateClassStructure(Type.getObjectType("libvtx/VGenerated"));
+
+        try (var outputStream = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(output), 20480))) {
+            var oot = transform.getOutput();
+            for (var entry : oot.entrySet()) {
+                // System.out.println("Writing " + entry.getKey());
+                outputStream.putNextEntry(new ZipEntry(entry.getKey() + ".class"));
+                outputStream.write(entry.getValue());
+            }
+
+            outputStream.putNextEntry(new ZipEntry("kfc/vivo50/code45/StubClasses.class"));
+
+            var cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+            cw.visit(Opcodes.V11, Opcodes.ACC_PUBLIC, "kfc/vivo50/code45/StubClasses", null, "java/lang/Object", null);
+
+            HelperTask.classInit(cw);
+
+            {
+                var mt = cw.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "classes", "()Ljava/util/List;", null, null);
+                mt.visitTypeInsn(Opcodes.NEW, "java/util/ArrayList");
+                mt.visitInsn(Opcodes.DUP);
+                mt.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/util/ArrayList", "<init>", "()V", false);
+
+                for (var name : oot.keySet()) {
+                    mt.visitInsn(Opcodes.DUP);
+                    mt.visitLdcInsn(Type.getObjectType(name));
+                    mt.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/util/ArrayList", "add", "(Ljava/lang/Object;)Z", false);
+                    mt.visitInsn(Opcodes.POP);
+                }
+
+                mt.visitInsn(Opcodes.ARETURN);
+                mt.visitMaxs(0, 0);
+            }
+
+            outputStream.write(cw.toByteArray());
+        }
+    }
+}

settings.gradle

@@ -0,0 +1,5 @@
+rootProject.name = 'kuimivm'
+
+include ':tencent'
+include ':struct-define'
+include ':packer'

src/main/java/com/kiliokuara/kuimivm/KuimiClass.java

@@ -0,0 +1,203 @@
+package com.kiliokuara.kuimivm;
+
+import com.kiliokuara.kuimivm.objects.KuimiArrays;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+import java.lang.reflect.Modifier;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+public class KuimiClass extends KuimiObject<Class<?>> {
+    private static final int CLASS_STATE_NOT_INITIALIZED = 0;
+    private static final int CLASS_STATE_CALLING_CLINIT = -1;
+    private static final int CLASS_STATE_INITIALIZED = 1;
+    private static final int CLASS_STATE_ERROR = -2;
+
+    private final KuimiVM vm;
+    private final Type classType;
+    private final KuimiObject<?> classLoader;
+    private final KuimiClass parent;
+    private final List<KuimiClass> itfs;
+    private final int modifiers;
+
+
+    private final KuimiMethodTable methodTable;
+    private final KuimiFieldTable fieldTable;
+
+    private volatile int classState = CLASS_STATE_NOT_INITIALIZED;
+
+
+    public KuimiClass(
+            KuimiVM vm, Type classType,
+            int modifiers,
+            KuimiObject<?> classLoader,
+            KuimiClass parentClass,
+            List<KuimiClass> interfaces
+    ) {
+        Objects.requireNonNull(vm, "vm");
+        Objects.requireNonNull(classType, "classType");
+
+        if ((modifiers & Opcodes.ACC_INTERFACE) != 0) {
+            modifiers |= Opcodes.ACC_ABSTRACT;
+        }
+
+        this.modifiers = modifiers;
+        this.vm = vm;
+        this.classType = classType; // fixme check name
+        this.classLoader = classLoader;
+        this.parent = parentClass;
+        this.itfs = interfaces == null ? Collections.emptyList() : interfaces;
+
+        this.methodTable = new KuimiMethodTable(this);
+        this.fieldTable = new KuimiFieldTable(this);
+    }
+
+    @Override
+    public KuimiVM getVm() {
+        return vm;
+    }
+
+    @Override
+    public KuimiClass getObjectClass() {
+        return vm.getClassClass();
+    }
+
+    public KuimiObject<?> getClassLoader() {
+        return classLoader;
+    }
+
+    /**
+     * Internal name
+     */
+    public String getTypeName() {
+        return classType.getClassName();
+    }
+
+    public Type getClassType() {
+        return classType;
+    }
+
+    public KuimiClass getSuperClass() {
+        return parent;
+    }
+
+    public List<KuimiClass> getInterfaces() {
+        return itfs;
+    }
+
+    public int getModifiers() {
+        return modifiers;
+    }
+
+    public KuimiMethodTable getMethodTable() {
+        return methodTable;
+    }
+
+    public KuimiFieldTable getFieldTable() {
+        return fieldTable;
+    }
+
+    public boolean isPrimitive() {
+        var sort = classType.getSort();
+        return sort != Type.ARRAY && sort != Type.OBJECT;
+    }
+
+    public boolean isArray() {
+        return classType.getSort() == Type.ARRAY;
+    }
+
+    @Override
+    public String toString() {
+        if ((modifiers & Opcodes.ACC_INTERFACE) == 0) {
+            return "class " + getTypeName();
+        }
+        return "interface " + getTypeName();
+    }
+
+    public KuimiObject<?> allocateNewObject() {
+        if (this == vm.getClassClass()) throw new RuntimeException("Allocating java.lang.Class is not allowed");
+        if (Modifier.isAbstract(modifiers)) throw new RuntimeException("Allocating a abstract class");
+        var tsort = classType.getSort();
+        if (tsort == Type.ARRAY) {
+            throw new RuntimeException("Allocating a array type");
+        }
+        if (tsort != Type.OBJECT) {
+            throw new RuntimeException("Allocating a primitive class");
+        }
+
+        ensureClassInitialized();
+
+        return new KuimiObject<>(this);
+    }
+
+    transient KuimiArrays.ArrayClass arrayType;
+
+    public KuimiArrays.ArrayClass arrayType() {
+        if (arrayType != null) return arrayType;
+        synchronized (this) {
+            if (arrayType != null) return arrayType;
+
+            return arrayType = new KuimiArrays.ArrayClass(this);
+        }
+    }
+
+    public boolean isInterface() {
+        return Modifier.isInterface(modifiers);
+    }
+
+    public void ensureClassInitialized() {
+        var cs = classState;
+        if (cs == CLASS_STATE_INITIALIZED) return;
+        if (cs == CLASS_STATE_ERROR) {
+            throw new IllegalStateException("Exception when initialize " + this);
+        }
+
+        synchronized (this) {
+            cs = classState;
+            if (cs == CLASS_STATE_INITIALIZED) return;
+            if (cs == CLASS_STATE_CALLING_CLINIT) return;
+            if (cs == CLASS_STATE_ERROR) {
+                throw new IllegalStateException("Exception when initialize " + this);
+            }
+            if (cs == CLASS_STATE_NOT_INITIALIZED) {
+                classState = CLASS_STATE_CALLING_CLINIT;
+
+                try {
+                    if (parent != null) {
+                        parent.ensureClassInitialized();
+                    }
+
+                    var clinit = methodTable.getDeclaredMethods().stream()
+                            .filter(it -> Modifier.isStatic(it.getModifiers()))
+                            .filter(it -> it.getReturnType().getClassType().getSort() == Type.VOID)
+                            .filter(it -> it.getParameters().size() == 0)
+                            .filter(it -> it.getMethodName().equals("<clinit>"))
+                            .findFirst();
+
+                    if (clinit.isPresent()) {
+                        clinit.get().resolveMethodHandle().invokeExact(vm, vm.getStackTrace());
+                    }
+
+                    classState = CLASS_STATE_INITIALIZED;
+                } catch (Throwable throwable) {
+                    classState = CLASS_STATE_ERROR;
+
+                    if (throwable instanceof RuntimeException) throw (RuntimeException) throwable;
+                    if (throwable instanceof Error) throw (Error) throwable;
+                    throw new RuntimeException(throwable);
+                }
+            }
+        }
+    }
+
+
+    @Deprecated
+    public static class Internal {
+        public static void attachArrayType(KuimiClass thiz, KuimiArrays.ArrayClass arrType) {
+            thiz.arrayType = arrType;
+        }
+    }
+}
+

src/main/java/com/kiliokuara/kuimivm/KuimiField.java

@@ -0,0 +1,81 @@
+package com.kiliokuara.kuimivm;
+
+import org.objectweb.asm.Type;
+
+public class KuimiField extends KuimiMember {
+    private final KuimiClass declaredClass;
+    private final String name;
+    private final KuimiClass type;
+    private final int modifiers;
+
+    int slot = -1, objIndex = -1;
+    long offset = -1;
+
+    final long size;
+
+    public KuimiField(KuimiClass declaredClass, int modifiers, String name, KuimiClass type) {
+        this.declaredClass = declaredClass;
+        this.name = name;
+        this.type = type;
+        this.modifiers = modifiers;
+
+        this.size = switch (type.getClassType().getSort()) {
+            case Type.ARRAY, Type.OBJECT -> type.getVm().objectPointerSize();
+            case Type.BOOLEAN, Type.BYTE -> 1;
+            case Type.CHAR -> Character.BYTES;
+            case Type.SHORT -> Short.BYTES;
+            case Type.INT -> Integer.BYTES;
+            case Type.LONG -> Long.BYTES;
+            case Type.DOUBLE -> Double.BYTES;
+            case Type.FLOAT -> Float.BYTES;
+
+            default -> throw new RuntimeException("Assertion error: Cannot detect field type size");
+        };
+    }
+
+
+    public int getModifiers() {
+        return modifiers;
+    }
+
+    public KuimiClass getDeclaredClass() {
+        return declaredClass;
+    }
+
+    public KuimiClass getType() {
+        return type;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public String toString() {
+        var sb = new StringBuilder();
+        KuimiMethod.sharedAppendModifiers(modifiers, sb);
+
+        sb.append(declaredClass.getTypeName()).append(".").append(name).append(": ").append(type.getTypeName());
+        return sb.toString();
+    }
+
+
+    public int getFieldSlot() {
+        if (slot < 0) throw new IllegalStateException("Field slot not allocated");
+        return slot;
+    }
+
+    public int getObjectIndex() {
+        if (objIndex < 0) {
+            throw new IllegalStateException("Object index not allocated or field is not a object field");
+        }
+        return objIndex;
+    }
+
+    public long getOffset() {
+        if (offset < 0) {
+            throw new IllegalStateException("Offset not allocated");
+        }
+        return offset;
+    }
+}

src/main/java/com/kiliokuara/kuimivm/KuimiFieldTable.java

@@ -0,0 +1,289 @@
+package com.kiliokuara.kuimivm;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+public class KuimiFieldTable extends KuimiMemberTable {
+    private final KuimiClass declaredClass;
+    private final List<KuimiField> staticFields; // merged
+    private final List<KuimiField> objectFields; // merged
+    private final List<KuimiField> declaredFields;
+    private final List<KuimiField> mergedFields;
+
+    long staticFieldsSize, objectFieldsSize;
+    int staticObjectCount, objectCount;
+
+    public KuimiFieldTable(KuimiClass declaredClass) {
+        this.declaredClass = declaredClass;
+
+        this.staticFields = new ArrayList<>();
+        this.objectFields = new ArrayList<>();
+        this.declaredFields = new ArrayList<>();
+        this.mergedFields = new ArrayList<>();
+    }
+
+
+    public void addField(KuimiField field) {
+        Objects.requireNonNull(field, "field");
+        if (field.slot != -1) {
+            throw new IllegalStateException("Field is already attached.");
+        }
+        if (field.getDeclaredClass() != declaredClass) {
+            throw new IllegalStateException("Attaching non-class field");
+        }
+
+        {
+            var cmod = declaredClass.getModifiers();
+            if ((cmod & Opcodes.ACC_INTERFACE) != 0) {
+                var fmod = field.getModifiers();
+                if ((fmod & Opcodes.ACC_STATIC) == 0) {
+                    throw new IllegalArgumentException("Attaching a object field to a interface");
+                }
+            }
+        }
+
+        acquireModifyLock();
+        try {
+            if (findDeclaredField(field) != null) {
+                throw new IllegalStateException("Field " + field + " is already attached with same signature");
+            }
+
+            declaredFields.add(field);
+
+            field.slot = -2; // mark already attached
+        } finally {
+            releaseModifyLock();
+        }
+    }
+
+    public void closeTable() {
+        { // close parent first
+            var sup = declaredClass.getSuperClass();
+            if (sup != null) {
+                sup.getFieldTable().closeTable();
+            }
+        }
+
+        while (true) {
+            var s = status;
+            if (s > 0) {
+                throw new IllegalStateException("This field table is still under editing.");
+            }
+            if (s == 0) {
+                if (STATUS.compareAndSet((KuimiMemberTable) this, 0, -1)) {
+                    break;
+                }
+                continue;
+            }
+            return;
+        }
+
+        {
+            var sup = declaredClass.getSuperClass();
+            if (sup != null) {
+                var supft = sup.getFieldTable();
+                staticFieldsSize = supft.staticFieldsSize;
+                objectFieldsSize = supft.objectFieldsSize;
+
+                staticObjectCount = supft.staticObjectCount;
+                objectCount = supft.objectCount;
+
+                staticFields.addAll(supft.staticFields);
+                objectFields.addAll(supft.objectFields);
+
+                mergedFields.addAll(supft.mergedFields);
+            }
+        }
+
+
+        if (declaredClass.getSuperClass() == null) { // java.lang.Object or other no parent class
+            var jlc = declaredClass.getVm().getClassClass();
+            var jlo = declaredClass.getVm().getBaseClass();
+
+            var objFields = Stream.concat(jlc.getFieldTable().declaredFields.stream(), jlo.getFieldTable().declaredFields.stream())
+                    .filter(it -> !Modifier.isStatic(it.getModifiers()))
+                    .toList();
+
+            long spadding = 0;
+            for (var f : objFields) {
+                spadding = alignUp(spadding, f.size);
+                spadding += f.size;
+
+
+                boolean isObject;
+                {
+                    var stype = f.getType().getClassType().getSort();
+                    isObject = stype == Type.ARRAY || stype == Type.OBJECT;
+                }
+
+                if (isObject) {
+                    staticObjectCount++;
+                }
+            }
+            staticFieldsSize = spadding; // reserved for java.lang.Object & java.lang.Class fields
+        }
+
+        var sfstart = staticFieldsSize;
+        var ofstart = objectFieldsSize;
+
+        var oocount = objectCount;
+        var socount = staticObjectCount;
+
+        for (var f : declaredFields) {
+            var mod = f.getModifiers();
+            var isStatic = Modifier.isStatic(mod);
+            boolean isObject;
+            {
+                var stype = f.getType().getClassType().getSort();
+                isObject = stype == Type.ARRAY || stype == Type.OBJECT;
+            }
+
+            f.slot = mergedFields.size();
+            mergedFields.add(f);
+
+
+            if (isStatic) {
+                staticFields.add(f);
+
+                sfstart = alignUp(sfstart, f.size);
+                f.offset = sfstart;
+                sfstart += f.size;
+
+                if (isObject) {
+                    f.objIndex = socount;
+                    socount++;
+                }
+            } else {
+                objectFields.add(f);
+
+                ofstart = alignUp(ofstart, f.size);
+                f.offset = ofstart;
+                ofstart += f.size;
+
+                if (isObject) {
+                    f.objIndex = oocount;
+                    oocount++;
+                }
+            }
+        }
+
+        staticFieldsSize = sfstart;
+        objectFieldsSize = ofstart;
+
+        objectCount = oocount;
+        staticObjectCount = socount;
+
+        { // inherit java.lang.Class
+            var jc = declaredClass.getVm().getClassClass();
+            jc.getFieldTable().closeTable();
+        }
+    }
+
+    private KuimiField findDeclaredField(KuimiField req) {
+        for (var f : declaredFields) {
+            if (!f.getType().equals(req.getType())) continue;
+            if (!f.getName().equals(req.getName())) continue;
+
+            return f;
+        }
+        return null;
+    }
+
+
+    private static long alignUp(long n, long alignment) {
+        return (n + alignment - 1) & -alignment;
+    }
+
+    @Override
+    public String toString() {
+        var sb = new StringBuilder();
+        sb.append("FieldTable[").append(declaredClass.getTypeName())
+                .append(", status=").append(status)
+                .append(", objectFieldSize=").append(objectFieldsSize)
+                .append(", objectObjectCount=").append(objectCount)
+                .append(", staticFieldSize=").append(staticFieldsSize)
+                .append(", staticObjectCount=").append(staticObjectCount)
+                .append('\n');
+
+        var vp = true;
+        for (var f : mergedFields) {
+            if (vp && f.getDeclaredClass().equals(declaredClass)) {
+                sb.append("|===\n");
+                vp = false;
+            }
+
+            sb.append("| S[").append(f.slot).append("]<").append(f.offset).append("\t..").append(f.offset + f.size).append("\t>{").append(f.size).append("\t}");
+            if (f.objIndex != -1) {
+                sb.append('[').append(f.objIndex).append(']');
+            }
+            sb.append(' ').append(f).append('\n');
+        }
+        return sb.append(']').toString();
+    }
+
+    public List<KuimiField> getDeclaredFields() {
+        closeTable();
+        return Collections.unmodifiableList(declaredFields);
+    }
+
+    public List<KuimiField> getMergedFields() {
+        closeTable();
+        return Collections.unmodifiableList(mergedFields);
+    }
+
+    public List<KuimiField> getObjectFields() {
+        closeTable();
+        return Collections.unmodifiableList(objectFields);
+    }
+
+    public List<KuimiField> getStaticFields() {
+        closeTable();
+        return Collections.unmodifiableList(staticFields);
+    }
+
+    public KuimiClass getDeclaredClass() {
+        return declaredClass;
+    }
+
+    public long getObjectFieldsSize() {
+        closeTable();
+        return objectFieldsSize;
+    }
+
+    public long getStaticFieldsSize() {
+        closeTable();
+        return staticFieldsSize;
+    }
+
+    public KuimiField findField(boolean isStatic, String name) {
+        closeTable();
+        for (var iterator = mergedFields.listIterator(mergedFields.size()); iterator.hasPrevious(); ) {
+            var f = iterator.previous();
+
+            if (Modifier.isStatic(f.getModifiers()) != isStatic) continue;
+            if (!f.getName().equals(name)) continue;
+            return f;
+        }
+        return null;
+    }
+
+    public KuimiField findField(boolean isStatic, String name, KuimiClass type) {
+        closeTable();
+        for (var iterator = mergedFields.listIterator(mergedFields.size()); iterator.hasPrevious(); ) {
+            var f = iterator.previous();
+
+            if (Modifier.isStatic(f.getModifiers()) != isStatic) continue;
+            if (!f.getType().equals(type)) continue;
+            if (!f.getName().equals(name)) continue;
+            return f;
+        }
+        return null;
+    }
+}

src/main/java/com/kiliokuara/kuimivm/KuimiMember.java

@@ -0,0 +1,18 @@
+package com.kiliokuara.kuimivm;
+
+import com.kiliokuara.kuimivm.attributes.AttributeMap;
+
+public abstract class KuimiMember {
+    public abstract KuimiClass getDeclaredClass();
+
+    private volatile AttributeMap<? extends KuimiMember> attributeMap;
+
+    public AttributeMap<? extends KuimiMember> getAttributeMap() {
+        if (attributeMap != null) return attributeMap;
+
+        synchronized (this) {
+            if (attributeMap != null) return attributeMap;
+            return attributeMap = new AttributeMap<>(this);
+        }
+    }
+}

src/main/java/com/kiliokuara/kuimivm/KuimiMemberTable.java

@@ -0,0 +1,40 @@
+package com.kiliokuara.kuimivm;
+
+import java.lang.invoke.ConstantBootstraps;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+
+public class KuimiMemberTable {
+    protected volatile int status;
+    static final VarHandle STATUS = ConstantBootstraps.fieldVarHandle(
+            MethodHandles.lookup(), "status", VarHandle.class,
+            KuimiMemberTable.class, int.class
+    ).withInvokeExactBehavior();
+
+
+
+    public boolean isImmutable() {
+        return status < 0;
+    }
+
+    protected final void acquireModifyLock() {
+        while (true) {
+            var s = status;
+            if (s < 0) {
+                throw new IllegalStateException("This method table is immutable.");
+            }
+            if (STATUS.compareAndSet(this, s, s + 1)) return;
+        }
+    }
+
+    protected final void releaseModifyLock() {
+        while (true) {
+            var s = status;
+            if (s < 1) {
+                throw new IllegalStateException("Internal exception: bad status, no lock can be released.");
+            }
+            if (STATUS.compareAndSet(this, s, s - 1)) return;
+        }
+    }
+
+}

src/main/java/com/kiliokuara/kuimivm/KuimiMethod.java

@@ -0,0 +1,396 @@
+package com.kiliokuara.kuimivm;
+
+import com.kiliokuara.kuimivm.execute.StackTrace;
+import com.kiliokuara.kuimivm.vaarg.KuimiMethodInvoker;
+import com.kiliokuara.kuimivm.vaarg.ShortenType;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class KuimiMethod extends KuimiMember {
+    private final KuimiClass declaredClass;
+    private final int modifiers;
+    private final String methodName;
+    private final KuimiClass returnType;
+    private final List<KuimiClass> params;
+    private final List<ShortenType> paramsShorten;
+    private final List<ShortenType> fullCallShorten;
+
+    int methodSlot = -1;
+
+
+    public KuimiMethod(
+            KuimiClass declaredClass,
+            int modifiers,
+            String methodName,
+            KuimiClass returnType,
+            List<KuimiClass> params
+    ) {
+        this.declaredClass = declaredClass;
+        this.modifiers = modifiers;
+        this.methodName = methodName;
+        this.returnType = returnType;
+        this.params = params == null ? List.of() : params;
+
+        paramsShorten = this.params.stream().map(it -> ShortenType.from(it.getClassType())).toList();
+        if (Modifier.isStatic(modifiers)) {
+            fullCallShorten = paramsShorten;
+        } else {
+            fullCallShorten = Stream.concat(Stream.of(ShortenType.REF), paramsShorten.stream()).toList();
+        }
+    }
+
+
+    public KuimiClass getDeclaredClass() {
+        return declaredClass;
+    }
+
+    public KuimiClass getAttachedClass() {
+        return declaredClass;
+    }
+
+    public int getModifiers() {
+        return modifiers;
+    }
+
+    public KuimiClass getReturnType() {
+        return returnType;
+    }
+
+    public List<KuimiClass> getParameters() {
+        return params;
+    }
+
+    public List<ShortenType> getParamsShorten() {
+        return paramsShorten;
+    }
+
+    public String getMethodName() {
+        return methodName;
+    }
+
+    @Override
+    public String toString() {
+        var sb = new StringBuilder();
+        sharedAppendModifiers(modifiers, sb);
+        sb.append(declaredClass.getTypeName()).append('.');
+        sb.append(methodName);
+        sb.append(params.stream()
+                .map(KuimiClass::getTypeName)
+                .collect(Collectors.joining(", ", "(", ")"))
+        );
+        sb.append(": ").append(returnType.getTypeName());
+
+        return sb.toString();
+    }
+
+    static void sharedAppendModifiers(int modifiers, StringBuilder sb) {
+        if (Modifier.isPublic(modifiers)) {
+            sb.append("public ");
+        }
+        if (Modifier.isPrivate(modifiers)) {
+            sb.append("private ");
+        }
+        if (Modifier.isProtected(modifiers)) {
+            sb.append("protected ");
+        }
+        if (Modifier.isStatic(modifiers)) {
+            sb.append("static ");
+        }
+        if (Modifier.isNative(modifiers)) {
+            sb.append("native ");
+        }
+        if (Modifier.isSynchronized(modifiers)) {
+            sb.append("synchronized ");
+        }
+        if (Modifier.isAbstract(modifiers)) {
+            sb.append("abstract ");
+        }
+        if (Modifier.isVolatile(modifiers)) {
+            sb.append("volatile ");
+        }
+        if (Modifier.isFinal(modifiers)) {
+            sb.append("final ");
+        }
+    }
+
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) return false;
+        if (obj == this) return true;
+        if (!(obj instanceof KuimiMethod other)) return false;
+        if (methodSlot != -1 && other.methodSlot != -1) {
+            if (methodSlot != other.methodSlot) return false;
+        }
+        if (modifiers != other.modifiers) return false;
+        if (!declaredClass.equals(other.declaredClass)) return false;
+        if (!returnType.equals(other.returnType)) return false;
+        if (!methodName.equals(other.methodName)) return false;
+        if (!params.equals(other.params)) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return methodName.hashCode() & (modifiers ^ returnType.hashCode()) + params.hashCode() ^ declaredClass.hashCode();
+    }
+
+    public int getMethodSlot() {
+        if (methodSlot < 0) throw new IllegalStateException("Method slot not allocated");
+        return methodSlot;
+    }
+
+    // region Execute
+    private transient volatile MethodHandle targetMH;
+    private transient volatile MethodType targetMHType;
+    private transient volatile KuimiMethodInvoker invoker;
+
+    public MethodHandle resolveMethodHandle() {
+        if (targetMH != null) return targetMH;
+
+        var mhType = flattenMethodHandleType();
+        if (getClass() != KuimiMethod.class) {
+            var lk = MethodHandles.lookup();
+            try {
+                lk = MethodHandles.privateLookupIn(getClass(), lk);
+            } catch (Exception ignored) {
+            }
+
+            try {
+                return targetMH = Internal.stackEnter(this, lk.findVirtual(getClass(), "execute", mhType).bindTo(this));
+            } catch (Exception e) {
+                return targetMH = Internal.notImplemented(this, mhType, e);
+            }
+        }
+
+        return targetMH = Internal.notImplemented(this, mhType, null);
+    }
+
+    public final KuimiMethod attachImplementation(KuimiMethod method) {
+        Objects.requireNonNull(method, "method");
+        if (getClass() != KuimiMethod.class) {
+            throw new IllegalStateException("Cannot attach a method handle to " + getClass());
+        }
+        if (!method.flattenMethodHandleType().equals(flattenMethodHandleType())) {
+            throw new IllegalArgumentException("Method type not match: " + method.flattenMethodHandleType() + " -> " + flattenMethodHandleType());
+        }
+        if (targetMH != null) {
+            throw new IllegalStateException("This method " + this + " is already attached.");
+        }
+        targetMH = method.resolveMethodHandle();
+        return this;
+    }
+
+    public final KuimiMethod attachImplementation(MethodHandle methodHandle) {
+        Objects.requireNonNull(methodHandle, "methodHandle");
+        if (getClass() != KuimiMethod.class) {
+            throw new IllegalStateException("Cannot attach a method handle to " + getClass());
+        }
+        if (!methodHandle.type().equals(flattenMethodHandleType())) {
+            throw new IllegalArgumentException("Method type not match: " + methodHandle.type() + " -> " + flattenMethodHandleType());
+        }
+        if (targetMH != null) {
+            throw new IllegalStateException("This method " + this + " is already attached.");
+        }
+        targetMH = Internal.stackEnter(this, methodHandle);
+        return this;
+    }
+
+    public final MethodType flattenMethodHandleType() {
+        if (targetMHType != null) {
+            return targetMHType;
+        }
+
+        var retType = switch (returnType.getClassType().getSort()) {
+            case Type.BYTE -> byte.class;
+            case Type.CHAR -> char.class;
+            case Type.SHORT -> short.class;
+            case Type.INT -> int.class;
+            case Type.LONG -> long.class;
+            case Type.FLOAT -> float.class;
+            case Type.DOUBLE -> double.class;
+            case Type.BOOLEAN -> boolean.class;
+            case Type.VOID -> void.class;
+            case Type.ARRAY, Type.OBJECT -> KuimiObject.class;
+            default -> throw new RuntimeException("Cannot confirm return type");
+        };
+
+        var args = new ArrayList<Class<?>>();
+        args.add(KuimiVM.class);
+        args.add(StackTrace.class);
+
+        if ((modifiers & Opcodes.ACC_STATIC) == 0) {
+            args.add(KuimiObject.class); // the this object
+        }
+
+        for (var param : params) {
+            args.add(switch (param.getClassType().getSort()) {
+                case Type.BYTE -> byte.class;
+                case Type.CHAR -> char.class;
+                case Type.SHORT -> short.class;
+                case Type.INT -> int.class;
+                case Type.LONG -> long.class;
+                case Type.FLOAT -> float.class;
+                case Type.DOUBLE -> double.class;
+                case Type.BOOLEAN -> boolean.class;
+                case Type.ARRAY, Type.OBJECT -> KuimiObject.class;
+                default -> throw new RuntimeException("Cannot confirm param type: " + param);
+            });
+        }
+
+        return targetMHType = MethodType.methodType(retType, args);
+    }
+
+    public KuimiMethodInvoker getInvoker() {
+        if (invoker != null) return invoker;
+
+        if (Modifier.isStatic(modifiers)) {
+            return invoker = KuimiMethodInvoker.invoker(returnType, params);
+        } else {
+            var prm = new ArrayList<KuimiClass>();
+            prm.add(declaredClass.getVm().getBaseClass());
+            prm.addAll(params);
+            return invoker = KuimiMethodInvoker.invoker(returnType, prm);
+        }
+    }
+
+
+    public boolean isInterfaceMethod() {
+        return declaredClass.isInterface();
+    }
+
+    public boolean isMergedInterface() {
+        return false;
+    }
+
+    public List<ShortenType> getFullCallShorten() {
+        return fullCallShorten;
+    }
+    // endregion
+
+
+    static class Internal {
+        private static final MethodHandle NEW_ERROR;
+        private static final MethodHandle NEW_ERROR_WITH_REASON;
+
+
+        private static final MethodHandle ENTER_STACK;
+        private static final MethodHandle LEAVE_STACK;
+
+
+        // out: (KuimiMethod, Throwable, <V>, KVM, StackTrace)<V>
+        private static final ClassValue<MethodHandle> RTYPE_ID_CLEANUP_CACHE = new ClassValue<>() {
+            @Override
+            protected MethodHandle computeValue(Class<?> rtype) {
+                if (rtype == void.class) {
+                    return LEAVE_STACK;
+                } else {
+                    MethodHandle cleanup = MethodHandles.identity(rtype);
+
+                    cleanup = MethodHandles.collectArguments(cleanup, 1, LEAVE_STACK);
+                    // now: (V, KuimiMethod, Throwable, KVM, StackTrace)V
+
+                    // target: (KuimiMethod, Throwable, V, KVM, StackTrace)V
+                    return MethodHandles.permuteArguments(cleanup,
+                            MethodType.methodType(rtype, KuimiMethod.class, Throwable.class, rtype, KuimiVM.class, StackTrace.class),
+                            2, 0, 1, 3, 4
+                    );
+                }
+            }
+        };
+
+        static {
+            var lk = MethodHandles.lookup();
+            try {
+                NEW_ERROR = lk.findConstructor(InternalError.class, MethodType.methodType(void.class, String.class));
+                NEW_ERROR_WITH_REASON = lk.findConstructor(InternalError.class, MethodType.methodType(void.class, String.class, Throwable.class));
+
+                ENTER_STACK = lk.findStatic(Internal.class, "enterStack", MethodType.methodType(void.class, KuimiMethod.class, KuimiVM.class, StackTrace.class));
+                LEAVE_STACK = lk.findStatic(Internal.class, "leaveStack", MethodType.methodType(void.class, KuimiMethod.class, Throwable.class, KuimiVM.class, StackTrace.class));
+            } catch (NoSuchMethodException | IllegalAccessException e) {
+                throw new ExceptionInInitializerError(e);
+            }
+        }
+
+        private static void enterStack(KuimiMethod method, KuimiVM vm, StackTrace stackTrace) {
+            // new Throwable("enter stack: " + method + " - " + stackTrace).printStackTrace(System.out);
+            if (stackTrace != null) {
+                stackTrace.enter(method);
+                stackTrace.pushFrame();
+            }
+        }
+
+        private static void leaveStack(KuimiMethod method, Throwable throwable, KuimiVM vm, StackTrace stackTrace) {
+            // new Throwable("leave stack: " + method + " - " + stackTrace).printStackTrace(System.out);
+            if (stackTrace != null) {
+                stackTrace.leave(method);
+            }
+        }
+
+        public static MethodHandle notImplemented(KuimiMethod kuimiMethod, MethodType mhType, Throwable exception) {
+            var msg = "Exception when binding implementation to " + kuimiMethod;
+            MethodHandle emh;
+            if (exception == null) {
+                emh = NEW_ERROR.bindTo(msg);
+            } else {
+                emh = MethodHandles.insertArguments(NEW_ERROR_WITH_REASON, 0, msg, exception);
+            }
+
+            var terr = MethodHandles.throwException(mhType.returnType(), InternalError.class);
+            var empThrow = MethodHandles.collectArguments(terr, 0, emh);
+
+
+            return MethodHandles.dropArguments(empThrow, 0, mhType.parameterArray());
+        }
+
+        public static MethodHandle stackEnter(KuimiMethod kuimiMethod, MethodHandle execute) {
+            return MethodHandles.tryFinally(
+                    MethodHandles.foldArguments(execute, ENTER_STACK.bindTo(kuimiMethod)),
+                    RTYPE_ID_CLEANUP_CACHE.get(execute.type().returnType()).bindTo(kuimiMethod)
+            );
+        }
+
+        static class DelegatedMethod extends KuimiMethod {
+
+            final KuimiMethod original;
+            private final KuimiClass attachedClass;
+
+            public DelegatedMethod(KuimiMethod original, KuimiClass attachedClass) {
+                super(original.declaredClass, original.modifiers, original.methodName, original.returnType, original.params);
+                this.original = original;
+                this.attachedClass = attachedClass;
+            }
+
+            @Override
+            public MethodHandle resolveMethodHandle() {
+                return original.resolveMethodHandle();
+            }
+
+            @Override
+            public KuimiClass getAttachedClass() {
+                return attachedClass;
+            }
+
+            @Override
+            public KuimiMethodInvoker getInvoker() {
+                return original.getInvoker();
+            }
+
+            @Override
+            public boolean isMergedInterface() {
+                return true;
+            }
+        }
+    }
+}

src/main/java/com/kiliokuara/kuimivm/KuimiMethodTable.java

@@ -0,0 +1,479 @@
+package com.kiliokuara.kuimivm;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+import java.lang.reflect.Modifier;
+import java.util.*;
+
+public class KuimiMethodTable extends KuimiMemberTable {
+    private final KuimiClass declaredClass;
+
+    private final List<KuimiMethod> mergedMethods;
+    private final List<KuimiMethod> declaredMethods;
+    private final Map<KuimiClass, InterfaceMethodTable> interfaceMethodTableMap;
+
+    public KuimiMethodTable(KuimiClass declaredClass) {
+        this.declaredClass = declaredClass;
+        mergedMethods = new ArrayList<>();
+        declaredMethods = new ArrayList<>();
+        interfaceMethodTableMap = new IdentityHashMap<>();
+    }
+
+    public void closeTable() {
+        { // close parent & itfs' tables first
+            var sup = declaredClass.getSuperClass();
+            if (sup != null) sup.getMethodTable().closeTable();
+
+            for (var itf : declaredClass.getInterfaces()) {
+                itf.getMethodTable().closeTable();
+            }
+        }
+
+        while (true) {
+            var s = status;
+            if (s > 0) {
+                throw new IllegalStateException("This method table is still under editing.");
+            }
+            if (s == 0) {
+                if (STATUS.compareAndSet((KuimiMemberTable) this, 0, -1)) break;
+                continue;
+            }
+            return;
+        }
+
+        var pendingMethods = new ArrayList<>(declaredMethods);
+
+        { // inherit super class methods
+            var sup = declaredClass.getSuperClass();
+            if (sup != null) {
+                mergedMethods.addAll(sup.getMethodTable().mergedMethods);
+            }
+        }
+
+
+        final var Helper = new Object() {
+            String pkg(Type ctype) {
+                var cname = ctype.getClassName();
+                var idx = cname.lastIndexOf('.');
+                if (idx == -1) return "";
+                return cname.substring(0, idx);
+            }
+
+            @SuppressWarnings("StatementWithEmptyBody")
+            KuimiMethod tryFindOverride(KuimiMethod req) {
+                for (var met : mergedMethods) {
+                    var modifiers = met.getModifiers();
+
+                    if (Modifier.isPrivate(modifiers)) continue;
+                    if (Modifier.isStatic(modifiers)) continue;
+
+                    // modifier check
+                    if (Modifier.isPublic(modifiers)) {
+                        // noop, ok
+                    } else if (Modifier.isProtected(modifiers)) {
+                        // noop, ok
+                    } else { // package private
+                        if (!Objects.equals(
+                                declaredClass.getClassLoader(),
+                                met.getDeclaredClass().getClassLoader()
+                        )) { // class loader not match, skip
+                            continue;
+                        }
+
+                        if (!Objects.equals(
+                                pkg(declaredClass.getClassType()),
+                                pkg(met.getDeclaredClass().getClassType())
+                        )) { // package not match, skip
+                            continue;
+                        }
+                    }
+
+
+                    if (!isSignMatch(req, met)) continue;
+
+                    return met;
+                }
+                return null;
+            }
+
+            boolean isSignMatch(KuimiMethod req, KuimiMethod met) {
+                if (!req.getReturnType().equals(met.getReturnType())) return false;
+                if (!req.getParameters().equals(met.getParameters())) return false;
+                if (!req.getMethodName().equals(met.getMethodName())) return false;
+
+                return true;
+            }
+
+            KuimiMethod findPublic(KuimiMethod req) {
+                for (var met : mergedMethods) {
+                    var mod = met.getModifiers();
+                    if (Modifier.isStatic(mod)) continue;
+                    if (!Modifier.isPublic(mod)) continue;
+
+                    if (!isSignMatch(req, met)) continue;
+
+                    return met;
+                }
+                return null;
+            }
+        };
+
+        { // step 1. Direct inherit static/private/<init> methods
+            pendingMethods.removeIf(it -> {
+
+                check:
+                {
+                    var mod = it.getModifiers();
+                    if (Modifier.isStatic(mod)) break check;
+                    if (Modifier.isPrivate(mod)) break check;
+
+                    if ("<init>".equals(it.getMethodName())) break check;
+
+                    return false;
+                }
+
+                it.methodSlot = mergedMethods.size();
+                mergedMethods.add(it);
+                return true;
+            });
+        }
+
+        { // step 2. try override methods
+            pendingMethods.removeIf(it -> {
+                var theOverride = Helper.tryFindOverride(it);
+                if (theOverride != null) {
+                    if (Modifier.isFinal(theOverride.getModifiers())) {
+                        throw new IllegalStateException("Method " + it + " trying overriding a final method: " + theOverride);
+                    }
+
+                    it.methodSlot = theOverride.methodSlot;
+                    mergedMethods.set(theOverride.methodSlot, it);
+                    return true;
+                }
+                return false;
+            });
+        }
+
+        { // step 3. merge pending methods
+            pendingMethods.removeIf(it -> {
+                it.methodSlot = mergedMethods.size();
+                mergedMethods.add(it);
+
+                return true;
+            });
+        }
+
+        // step 4. merge interfaces
+        if (!declaredClass.getInterfaces().isEmpty()) {
+            for (var itfx : declaredClass.getInterfaces()) {
+                pendingMethods.addAll(itfx.getMethodTable().getMergedMethods());
+            }
+
+            // drop static/private methods (not used in itf table)
+            pendingMethods.removeIf(it -> Modifier.isStatic(it.getModifiers()) || Modifier.isPrivate(it.getModifiers()));
+
+            // drop already exists methods
+            pendingMethods.removeIf(it -> Helper.findPublic(it) != null);
+
+            { // drop empty method if possible
+                var mirror = new ArrayList<>(pendingMethods);
+                pendingMethods.removeIf(it -> {
+                    if ((it.getModifiers() & Opcodes.ACC_ABSTRACT) != 0) {
+
+                        for (var met : mirror) {
+                            if ((it.getModifiers() & Opcodes.ACC_ABSTRACT) != 0) continue;
+                            if (!Helper.isSignMatch(it, met)) continue;
+
+                            return true;
+                        }
+
+                    }
+                    return false;
+                });
+            }
+
+            { // drop duplicated empty method
+                topScan:
+                while (true) {
+                    //var mirror = new ArrayList<>(pendingMethods);
+
+                    for (var iterator = pendingMethods.iterator(); iterator.hasNext(); ) {
+                        var it = iterator.next();
+
+                        if ((it.getModifiers() & Opcodes.ACC_ABSTRACT) == 0) continue;
+
+
+                        for (var met : pendingMethods) {
+                            if (met == it) continue;
+
+                            if ((met.getModifiers() & Opcodes.ACC_ABSTRACT) == 0) continue;
+                            if (!Helper.isSignMatch(it, met)) continue;
+
+                            iterator.remove();
+                            continue topScan;
+                        }
+
+                    }
+
+                    break;
+                }
+            }
+
+            { // check duplicated method not exists
+                for (var it : pendingMethods) {
+                    for (var met : pendingMethods) {
+                        if (met == it) continue;
+
+                        check:
+                        {
+                            if (Helper.isSignMatch(met, it)) break check;
+
+                            continue;
+                        }
+
+                        throw new IllegalStateException("Duplicated interface define method found: " + met + ", " + it);
+                    }
+                }
+            }
+
+
+            for (var met : pendingMethods) {
+                var copied = new KuimiMethod.Internal.DelegatedMethod(met, declaredClass);
+                copied.methodSlot = mergedMethods.size();
+                mergedMethods.add(copied);
+            }
+
+        }
+
+        // step 5. recalculate interface method table
+        if (declaredClass.getInterfaces().isEmpty() && (declaredClass.getModifiers() & Opcodes.ACC_INTERFACE) == 0) {
+
+            var sup = declaredClass.getSuperClass();
+            if (sup != null) {
+                interfaceMethodTableMap.putAll(sup.getMethodTable().interfaceMethodTableMap);
+            }
+        } else {
+            var allItfs = new HashSet<KuimiClass>();
+            {
+                var sup = declaredClass.getSuperClass();
+                if (sup != null) {
+                    allItfs.addAll(sup.getMethodTable().interfaceMethodTableMap.keySet());
+                }
+            }
+            allItfs.addAll(declaredClass.getInterfaces());
+            for (var itfx : declaredClass.getInterfaces()) {
+                allItfs.addAll(itfx.getMethodTable().interfaceMethodTableMap.keySet());
+            }
+
+            if ((declaredClass.getModifiers() & Opcodes.ACC_INTERFACE) != 0) {
+                allItfs.add(declaredClass);
+            }
+
+            for (var itf : allItfs) {
+                var methods = itf.getMethodTable().getMergedMethods();
+                var slots = new int[methods.size()];
+                for (int i = 0, methodsSize = methods.size(); i < methodsSize; i++) {
+                    var itfMet = methods.get(i);
+
+                    if (Modifier.isPrivate(itfMet.getModifiers())) continue;
+                    if (Modifier.isStatic(itfMet.getModifiers())) continue;
+
+                    var mtx = Helper.findPublic(itfMet);
+                    if (mtx == null) {
+                        throw new IllegalStateException("Internal exception: " + itfMet + " lost. request itf: " + itf);
+                    }
+                    slots[i] = mtx.methodSlot;
+                }
+
+                interfaceMethodTableMap.put(itf, new InterfaceMethodTable(itf, slots));
+            }
+        }
+
+    }
+
+    public KuimiMethod addMethod(KuimiMethod kuimiMethod) {
+        Objects.requireNonNull(kuimiMethod);
+        if (kuimiMethod.methodSlot != -1) {
+            throw new RuntimeException("Target method already attached.");
+        }
+        if (kuimiMethod.getDeclaredClass() != this.declaredClass) {
+            throw new IllegalArgumentException("Declared class not match, table=" + declaredClass + ", method=" + kuimiMethod.getDeclaredClass());
+        }
+        acquireModifyLock();
+        try {
+            if (findDeclaredMethod(kuimiMethod) != null) {
+                throw new IllegalStateException("A method with same signature was already defined.");
+            }
+            declaredMethods.add(kuimiMethod);
+
+            kuimiMethod.methodSlot = -2; // mark as attached
+
+            return kuimiMethod;
+        } finally {
+            releaseModifyLock();
+        }
+    }
+
+
+    private KuimiMethod findDeclaredMethod(KuimiMethod tried) {
+        for (var dm : declaredMethods) {
+            if (dm.getReturnType() != tried.getReturnType()) continue;
+            if (!dm.getParameters().equals(tried.getParameters())) continue;
+            if (!dm.getMethodName().equals(tried.getMethodName())) continue;
+
+            return dm;
+        }
+
+        return null;
+    }
+
+
+    public List<KuimiMethod> getDeclaredMethods() {
+        closeTable();
+        return Collections.unmodifiableList(declaredMethods);
+    }
+
+    public List<KuimiMethod> getDeclaredMethodNoClose() {
+        return Collections.unmodifiableList(declaredMethods);
+    }
+
+    public List<KuimiMethod> getMergedMethods() {
+        closeTable();
+        return Collections.unmodifiableList(mergedMethods);
+    }
+
+    private List<KuimiMethod> loopedMethods(String name) {
+        if (name.equals("<clinit>") || name.equals("<init>")) return getDeclaredMethods();
+        return getMergedMethods();
+    }
+
+    public KuimiMethod resolveMethod(String name, KuimiClass retType, List<KuimiClass> params, boolean isStatic) {
+        var list = loopedMethods(name);
+        for (var iterator = list.listIterator(list.size()); iterator.hasPrevious(); ) {
+            var met = iterator.previous();
+
+            if (Modifier.isStatic(met.getModifiers()) != isStatic) continue;
+            if (!retType.equals(met.getReturnType())) continue;
+            if (!params.equals(met.getParameters())) continue;
+            if (!name.equals(met.getMethodName())) continue;
+            return met;
+        }
+        return null;
+    }
+
+    public KuimiMethod resolveMethod(String name, String desc, boolean isStatic) {
+        var retType = declaredClass.getVm().resolveClass(Type.getReturnType(desc));
+        var parmas = Arrays.stream(Type.getArgumentTypes(desc)).map(it -> declaredClass.getVm().resolveClass(it)).toList();
+        return resolveMethod(name, retType, parmas, isStatic);
+    }
+
+    @Override
+    public String toString() {
+        var sb = new StringBuilder();
+        sb.append("MethodTable[").append(declaredClass).append(", status=").append(status).append('\n');
+
+        sb.append("|= declared:\n");
+        for (var dec : declaredMethods) {
+            sb.append("| S[").append(dec.methodSlot).append("] ").append(dec).append('\n');
+        }
+        sb.append("|= merged:\n");
+        for (var dec : mergedMethods) {
+            sb.append("| S[").append(dec.methodSlot).append("] ").append(dec).append('\n');
+        }
+        sb.append("|= itfs:\n");
+        for (var itfs : interfaceMethodTableMap.entrySet()) {
+            sb.append("| |- ").append(itfs.getKey().getTypeName()).append("\n");
+
+            var mtTable = itfs.getValue().itfType.getMethodTable().mergedMethods;
+            var slotMap = itfs.getValue().slotMap;
+            var slotMapSize = slotMap.length;
+
+
+            for (int i = 0, mtTableSize = mtTable.size(); i < mtTableSize; i++) {
+                var met = mtTable.get(i);
+
+                if (Modifier.isStatic(met.getModifiers())) continue;
+                if (Modifier.isPrivate(met.getModifiers())) continue;
+
+                sb.append("| |  `- S[").append(i).append("->");
+                if (i < slotMapSize) {
+                    sb.append(slotMap[i]).append("\t] ").append(met);
+                    sb.append("\t\t-->  ").append(mergedMethods.get(slotMap[i]));
+                } else {
+                    sb.append("??\t] ").append(met);
+                }
+                sb.append('\n');
+            }
+
+        }
+
+
+        sb.append(']');
+        return sb.toString();
+    }
+
+    public Map<KuimiClass, InterfaceMethodTable> getInterfaceMethodTableMap() {
+        return Collections.unmodifiableMap(interfaceMethodTableMap);
+    }
+
+    public KuimiMethod resolveMethod(KuimiMethod method) {
+        var mod = method.getModifiers();
+        if (Modifier.isPrivate(mod)) return method;
+        if (Modifier.isStatic(mod)) return method;
+        if (method.isInterfaceMethod()) {
+            try {
+                var attached = method.getAttachedClass();
+                if (!attached.isInterface()) {
+                    // attached to parent class / current class
+                    return method;
+                }
+                var remapped = interfaceMethodTableMap.get(attached);
+                return getMergedMethods().get(remapped.slotMap[method.getMethodSlot()]);
+            } catch (Throwable throwable) {
+                throw new RuntimeException("Exception when resolving " + method + "<" + method.methodSlot + ">{" + method.getClass() + "} by " + this + ", \n" + method.getAttachedClass().getMethodTable());
+            }
+        }
+        return getMergedMethods().get(method.getMethodSlot());
+    }
+
+    public static class InterfaceMethodTable {
+        private final KuimiClass itfType;
+        private final int[] slotMap;
+
+        public InterfaceMethodTable(KuimiClass itfType, int[] slotMap) {
+            this.itfType = itfType;
+            this.slotMap = slotMap;
+        }
+
+        @Override
+        public String toString() {
+            var sb = new StringBuilder();
+            sb.append("InterfaceMethodTable[").append(itfType.getTypeName()).append('\n');
+
+            var mtTable = itfType.getMethodTable().getMergedMethods();
+
+            var slotMapLocal = slotMap;
+            var slotMapSize = slotMapLocal.length;
+
+            for (int i = 0, mtTableSize = mtTable.size(); i < mtTableSize; i++) {
+                var met = mtTable.get(i);
+
+                if (Modifier.isStatic(met.getModifiers())) continue;
+                if (Modifier.isPrivate(met.getModifiers())) continue;
+
+                sb.append("| S[").append(i).append("->");
+                if (i < slotMapSize) {
+                    sb.append(slotMapLocal[i]);
+                } else {
+                    sb.append("??");
+                }
+                sb.append("\t] ").append(met);
+                sb.append('\n');
+            }
+
+            sb.append(']');
+            return sb.toString();
+        }
+    }
+}

src/main/java/com/kiliokuara/kuimivm/KuimiObject.java

@@ -0,0 +1,66 @@
+package com.kiliokuara.kuimivm;
+
+import com.kiliokuara.kuimivm.attributes.AttributeMap;
+
+import java.util.Objects;
+
+public class KuimiObject<T> {
+    private final KuimiClass type;
+    protected volatile T delegateInstance;
+    private AttributeMap<KuimiObject<T>> attributeMap;
+
+
+    public KuimiObject(KuimiClass objectType) {
+        Objects.requireNonNull(objectType, "object type");
+        this.type = objectType;
+    }
+
+    KuimiObject() { // reserved for KuimiClass
+        this.type = null;
+    }
+
+    public KuimiVM getVm() {
+        assert type != null;
+        return type.getVm();
+    }
+
+    public T getDelegateInstance() {
+        return delegateInstance;
+    }
+
+    public void setDelegateInstance(T delegateInstance) {
+        this.delegateInstance = delegateInstance;
+    }
+
+    public KuimiClass getObjectClass() {
+        return type;
+    }
+
+    public AttributeMap<KuimiObject<T>> getAttributeMap() {
+        if (attributeMap != null) return attributeMap;
+        synchronized (this) {
+            if (attributeMap != null) return attributeMap;
+
+            return attributeMap = new AttributeMap<>(this);
+        }
+    }
+
+    public KuimiObjectMemory memoryView() {
+        return getAttributeMap().attribute(KuimiObjectMemory.ATTRIBUTE_KEY);
+    }
+
+    @Override
+    public String toString() {
+        var d = delegateInstance;
+        if (d != null) return d.toString();
+
+        return getObjectClass().getTypeName() + "@" + hashCode();
+    }
+
+    @Override
+    public int hashCode() {
+        var d = delegateInstance;
+        if (d != null) return d.hashCode();
+        return System.identityHashCode(this);
+    }
+}

src/main/java/com/kiliokuara/kuimivm/KuimiObjectMemory.java

@@ -0,0 +1,28 @@
+package com.kiliokuara.kuimivm;
+
+import com.kiliokuara.kuimivm.attributes.AttributeKey;
+
+import java.nio.ByteBuffer;
+
+/**
+ * Object fields' memory
+ */
+public class KuimiObjectMemory {
+    public static final AttributeKey<KuimiObject<?>, KuimiObjectMemory> ATTRIBUTE_KEY = new AttributeKey<>("field-table-memory", f -> {
+        if (f instanceof KuimiClass c) {
+            return new KuimiObjectMemory(c.getFieldTable(), true);
+        } else {
+            return new KuimiObjectMemory(f.getObjectClass().getFieldTable(), false);
+        }
+    });
+
+    public final ByteBuffer buffer;
+    public final KuimiObject<?>[] objects;
+
+    public KuimiObjectMemory(KuimiFieldTable table, boolean isStatic) {
+        buffer = ByteBuffer.allocate(
+                (int) (isStatic ? table.staticFieldsSize : table.objectFieldsSize)
+        );
+        objects = new KuimiObject[isStatic ? table.staticObjectCount : table.objectCount];
+    }
+}

src/main/java/com/kiliokuara/kuimivm/KuimiVM.java

@@ -0,0 +1,31 @@
+package com.kiliokuara.kuimivm;
+
+import com.kiliokuara.kuimivm.execute.StackTrace;
+import com.kiliokuara.kuimivm.execute.ObjectPool;
+import org.objectweb.asm.Type;
+
+public abstract class KuimiVM {
+    public abstract KuimiClass getBaseClass();
+
+    public abstract KuimiClass getClassClass();
+    public abstract KuimiClass getStringClass();
+
+    public abstract KuimiClass getPrimitiveClass(Type type);
+
+    public abstract long objectPointerSize();
+
+    public abstract KuimiClass resolveClass(Type type);
+
+    public abstract KuimiObject<?> resolveObject(int ptr);
+
+    public abstract ObjectPool getGlobalPool();
+
+    public abstract ObjectPool getWeakGlobalPool();
+
+
+    public abstract StackTrace getStackTrace();
+
+    public abstract void attachThread(StackTrace stackTrace);
+
+    public abstract void detatchThread();
+}

src/main/java/com/kiliokuara/kuimivm/abstractvm/ClassPool.java

@@ -0,0 +1,35 @@
+package com.kiliokuara.kuimivm.abstractvm;
+
+import com.kiliokuara.kuimivm.KuimiClass;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class ClassPool {
+    private ClassPool parent;
+    private final Map<String, KuimiClass> classMap = new ConcurrentHashMap<>();
+
+    public ClassPool() {
+    }
+
+    public ClassPool(ClassPool parent) {
+        this.parent = parent;
+    }
+
+    public void put(String type, KuimiClass target) {
+        classMap.put(type, target);
+    }
+
+    public void put(KuimiClass target) {
+        put(target.getTypeName(), target);
+    }
+
+    public KuimiClass resolve(String type) {
+        if (parent != null) {
+            var pt = parent.resolve(type);
+            if (pt != null) return pt;
+        }
+        return classMap.get(type);
+    }
+
+}

src/main/java/com/kiliokuara/kuimivm/abstractvm/KuimiAbstractVM.java

@@ -0,0 +1,515 @@
+package com.kiliokuara.kuimivm.abstractvm;
+
+import com.kiliokuara.kuimivm.*;
+import com.kiliokuara.kuimivm.execute.ObjectPool;
+import com.kiliokuara.kuimivm.execute.StackTrace;
+import com.kiliokuara.kuimivm.objects.KuimiArrays;
+import com.kiliokuara.kuimivm.objects.KuimiString;
+import com.kiliokuara.kuimivm.*;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+import java.lang.invoke.MethodHandles;
+import java.util.*;
+import java.util.function.BiConsumer;
+import java.util.function.IntFunction;
+
+public class KuimiAbstractVM extends KuimiVM {
+    private final ClassPool bootstrapPool = new ClassPool();
+    private final ObjectPool globalPool = new ObjectPool(this, 2048);
+    private final ObjectPool weakGlobalPool = new ObjectPool(this, 2048);
+
+    private final KuimiClass javaLangObject, javaLangClassLoader, javaLangClass, javaLangString;
+
+    private final ThreadLocal<StackTrace> THREAD_STACK_TRACE = new ThreadLocal<>();
+
+    @SuppressWarnings({"rawtypes", "unchecked", "unused"})
+    public KuimiAbstractVM() {
+        {// base classes
+            // TODO: sb
+            javaLangObject = new KuimiClass(this, Type.getObjectType("java/lang/Object"), Opcodes.ACC_PUBLIC, null, null, null);
+            javaLangClass = new KuimiClass(this, Type.getObjectType("java/lang/Class"), Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, null, javaLangObject, null);
+            bootstrapPool.put(javaLangObject);
+            bootstrapPool.put(javaLangClass);
+
+
+            { // primitive classes
+                for (var type : new Type[]{
+                        Type.BOOLEAN_TYPE,
+                        Type.BYTE_TYPE,
+                        Type.CHAR_TYPE,
+                        Type.SHORT_TYPE,
+                        Type.INT_TYPE,
+                        Type.LONG_TYPE,
+
+                        Type.FLOAT_TYPE,
+                        Type.DOUBLE_TYPE,
+
+                        Type.VOID_TYPE,
+                }) {
+                    var typeC = new KuimiClass(this, type, Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, null, null, null);
+                    bootstrapPool.put(typeC);
+                    typeC.getMethodTable().closeTable();
+                }
+
+                BiConsumer<KuimiClass, IntFunction<Object>> attachPM = (elmt, allo) -> {
+                    //noinspection deprecation
+                    KuimiClass.Internal.attachArrayType(elmt, new KuimiArrays.PrimitiveArrayClass(elmt, allo));
+                };
+
+                attachPM.accept(getPrimitiveClass(Type.BOOLEAN_TYPE), boolean[]::new);
+                attachPM.accept(getPrimitiveClass(Type.BYTE_TYPE), byte[]::new);
+                attachPM.accept(getPrimitiveClass(Type.CHAR_TYPE), char[]::new);
+                attachPM.accept(getPrimitiveClass(Type.SHORT_TYPE), short[]::new);
+                attachPM.accept(getPrimitiveClass(Type.INT_TYPE), int[]::new);
+                attachPM.accept(getPrimitiveClass(Type.LONG_TYPE), long[]::new);
+                attachPM.accept(getPrimitiveClass(Type.FLOAT_TYPE), float[]::new);
+                attachPM.accept(getPrimitiveClass(Type.DOUBLE_TYPE), double[]::new);
+            }
+
+            var javaLangCharSequence = new KuimiClass(this, Type.getObjectType("java/lang/CharSequence"), Opcodes.ACC_INTERFACE | Opcodes.ACC_PUBLIC, null, javaLangObject, null);
+            bootstrapPool.put(javaLangCharSequence);
+            var javaLangString = new KuimiClass(this, Type.getObjectType("java/lang/String"), Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, null, javaLangObject, List.of(javaLangCharSequence)) {
+                @Override
+                public KuimiObject<?> allocateNewObject() {
+                    return new KuimiString(KuimiAbstractVM.this, null);
+                }
+            };
+            bootstrapPool.put(javaLangString);
+            this.javaLangString = javaLangString;
+
+            javaLangClassLoader = new KuimiClass(this, Type.getObjectType("java/lang/ClassLoader"), Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, null, javaLangObject, null);
+            javaLangClassLoader.getMethodTable().addMethod(new KuimiMethod(javaLangClassLoader, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "getSystemClassLoader", javaLangClassLoader, List.of()) {
+                KuimiObject<?> execute(KuimiVM vm, StackTrace st) {
+                    KuimiObject<ClassLoader> object = new KuimiObject<>(javaLangClassLoader);
+                    object.setDelegateInstance(ClassLoader.getSystemClassLoader());
+                    return object;
+                }
+            });
+            javaLangClassLoader.getMethodTable().addMethod(new KuimiMethod(javaLangClassLoader, Opcodes.ACC_PUBLIC, "loadClass", javaLangClass, List.of(javaLangString)) {
+                KuimiObject<?> execute(KuimiVM vm, StackTrace st, KuimiObject<ClassLoader> kuimiObject, KuimiObject name) throws ClassNotFoundException {
+                    var obj = new KuimiObject<>(javaLangClass);
+                    System.out.println("!LoadClass: " + name.getDelegateInstance());
+                    obj.setDelegateInstance(kuimiObject.getDelegateInstance().loadClass((String) name.getDelegateInstance()));
+                    return obj;
+                }
+            });
+            bootstrapPool.put(javaLangClassLoader);
+
+            var javaIoSerializable = new KuimiClass(this, Type.getObjectType("java/io/Serializable"), Opcodes.ACC_INTERFACE | Opcodes.ACC_PUBLIC, null, javaLangObject, null);
+            var javaLangComparable = new KuimiClass(this, Type.getObjectType("java/lang/Comparable"), Opcodes.ACC_INTERFACE | Opcodes.ACC_PUBLIC, null, javaLangObject, null);
+            bootstrapPool.put(javaIoSerializable);
+            bootstrapPool.put(javaLangComparable);
+
+            KuimiClass javaLangThrowable = new KuimiClass(this, Type.getObjectType("java/lang/Throwable"), Opcodes.ACC_PUBLIC, null, javaLangObject, List.of(javaIoSerializable));
+            KuimiClass javaLangException = new KuimiClass(this, Type.getObjectType("java/lang/Exception"), Opcodes.ACC_PUBLIC, null, javaLangThrowable, null);
+            KuimiClass javaLangError = new KuimiClass(this, Type.getObjectType("java/lang/Error"), Opcodes.ACC_PUBLIC, null, javaLangThrowable, null);
+            KuimiClass javaLangRuntimeException = new KuimiClass(this, Type.getObjectType("java/lang/RuntimeException"), Opcodes.ACC_PUBLIC, null, javaLangException, null);
+            KuimiClass javaLangNullPointerException = new KuimiClass(this, Type.getObjectType("java/lang/NullPointerException"), Opcodes.ACC_PUBLIC, null, javaLangRuntimeException, null);
+            KuimiClass javaLangLinkageError = new KuimiClass(this, Type.getObjectType("java/lang/LinkageError"), Opcodes.ACC_PUBLIC, null, javaLangError, null);
+            KuimiClass javaLangNoClassDefFoundError = new KuimiClass(this, Type.getObjectType("java/lang/NoClassDefFoundError"), Opcodes.ACC_PUBLIC, null, javaLangLinkageError, null);
+            KuimiClass javaLangReflectiveOperationException = new KuimiClass(this, Type.getObjectType("java/lang/ReflectiveOperationException"), Opcodes.ACC_PUBLIC, null, javaLangException, null);
+            KuimiClass javaLangClassNotFoundException = new KuimiClass(this, Type.getObjectType("java/lang/ClassNotFoundException"), Opcodes.ACC_PUBLIC, null, javaLangReflectiveOperationException, null);
+
+            bootstrapPool.put(javaLangThrowable);
+            bootstrapPool.put(javaLangException);
+            bootstrapPool.put(javaLangError);
+            bootstrapPool.put(javaLangRuntimeException);
+            bootstrapPool.put(javaLangNullPointerException);
+            bootstrapPool.put(javaLangLinkageError);
+            bootstrapPool.put(javaLangNoClassDefFoundError);
+            bootstrapPool.put(javaLangReflectiveOperationException);
+            bootstrapPool.put(javaLangClassNotFoundException);
+
+
+            javaLangCharSequence.getMethodTable().addMethod(new KuimiMethod(javaLangCharSequence, Opcodes.ACC_ABSTRACT | Opcodes.ACC_PUBLIC, "length", getPrimitiveClass(Type.INT_TYPE), List.of()));
+            javaLangCharSequence.getMethodTable().addMethod(new KuimiMethod(javaLangCharSequence, Opcodes.ACC_ABSTRACT | Opcodes.ACC_PUBLIC, "charAt", getPrimitiveClass(Type.CHAR_TYPE), List.of(getPrimitiveClass(Type.INT_TYPE))));
+            javaLangCharSequence.getMethodTable().addMethod(new KuimiMethod(javaLangCharSequence, Opcodes.ACC_ABSTRACT | Opcodes.ACC_PUBLIC, "subSequence", javaLangCharSequence, List.of(getPrimitiveClass(Type.INT_TYPE), getPrimitiveClass(Type.INT_TYPE))));
+
+
+            javaLangObject.getMethodTable().addMethod(new KuimiMethod(javaLangObject, Opcodes.ACC_PUBLIC, "toString", javaLangString, List.of()) {
+                KuimiObject<?> execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz) {
+                    var toStrx = thiz.toString();
+                    if (toStrx != null) {
+                        return new KuimiString(vm, toStrx);
+                    }
+                    return null;
+                }
+            });
+            javaLangObject.getMethodTable().addMethod(new KuimiMethod(javaLangObject, Opcodes.ACC_PUBLIC, "hashCode", getPrimitiveClass(Type.INT_TYPE), List.of()) {
+                int execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz) {
+                    return thiz.hashCode();
+                }
+            });
+
+            {
+                var objInit = javaLangObject.getMethodTable()
+                        .addMethod(new KuimiMethod(javaLangObject, Opcodes.ACC_PUBLIC, "<init>", getPrimitiveClass(Type.VOID_TYPE), List.of()));
+                objInit.attachImplementation(MethodHandles.empty(objInit.flattenMethodHandleType()));
+            }
+            {
+                var javaLangRunnable = new KuimiClass(this, Type.getObjectType("java/lang/Runnable"), Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT | Opcodes.ACC_INTERFACE, null, javaLangObject, null);
+                javaLangRunnable.getMethodTable().addMethod(new KuimiMethod(javaLangRunnable, Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, "run", getPrimitiveClass(Type.VOID_TYPE), List.of()));
+            }
+
+
+            javaLangString.getMethodTable().addMethod(new KuimiMethod(javaLangString, Opcodes.ACC_PUBLIC, "<init>", getPrimitiveClass(Type.VOID_TYPE), List.of(getPrimitiveClass(Type.BYTE_TYPE).arrayType(), javaLangString)) {
+                void execute(KuimiVM vm, StackTrace st, KuimiObject<?> thiz, KuimiObject<?> barr, KuimiObject<?> charset) throws Throwable {
+                    ((KuimiString) thiz).forceChangeValue(
+                            new String((byte[]) barr.getDelegateInstance(), charset.toString())
+                    );
+                }
+            });
+            javaLangString.getMethodTable().addMethod(new KuimiMethod(javaLangString, Opcodes.ACC_PUBLIC, "<init>", getPrimitiveClass(Type.VOID_TYPE), List.of(getPrimitiveClass(Type.CHAR_TYPE).arrayType())) {
+                void execute(KuimiVM vm, StackTrace st, KuimiObject<?> thiz, KuimiObject<?> arr) throws Throwable {
+                    ((KuimiString) thiz).forceChangeValue(
+                            new String((char[]) arr.getDelegateInstance())
+                    );
+                }
+            });
+
+
+            { // stub field
+                // javaLangClass.getFieldTable().addField(new KuimiField(javaLangClass, Opcodes.ACC_PRIVATE, "stub1", getPrimitiveClass(Type.INT_TYPE)));
+                javaLangClass.getFieldTable().addField(new KuimiField(javaLangClass, Opcodes.ACC_PRIVATE, "classLoader", javaLangObject));
+                // javaLangClass.getFieldTable().addField(new KuimiField(javaLangClass, Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC, "CONST_0", getPrimitiveClass(Type.INT_TYPE)));
+                // javaLangClass.getFieldTable().addField(new KuimiField(javaLangClass, Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC, "CONST_1", javaLangObject));
+            }
+
+            { // collections
+                var iterator = new KuimiClass(this, Type.getType(Iterator.class), Opcodes.ACC_PUBLIC | Opcodes.ACC_INTERFACE, null, javaLangObject, null);
+                bootstrapPool.put(iterator);
+                iterator.getMethodTable().addMethod(new KuimiMethod(iterator, Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, "hasNext", getPrimitiveClass(Type.VOID_TYPE), null) {
+                    boolean execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof Iterator<?> itr) return itr.hasNext();
+                        throw new UnsupportedOperationException();
+                    }
+                });
+                iterator.getMethodTable().addMethod(new KuimiMethod(iterator, Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, "next", javaLangObject, null) {
+                    KuimiObject<?> execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof Iterator<?> itr) {
+                            var nxt = itr.next();
+                            if (nxt == null) return null;
+                            if (nxt instanceof KuimiObject<?>) return (KuimiObject<?>) nxt;
+                            if (nxt instanceof String) return new KuimiString(vm, nxt.toString());
+                            throw new UnsupportedOperationException(nxt + " <" + nxt.getClass() + ">");
+                        }
+                        throw new UnsupportedOperationException();
+                    }
+                });
+                iterator.getMethodTable().addMethod(new KuimiMethod(iterator, Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, "remove", getPrimitiveClass(Type.VOID_TYPE), null) {
+                    void execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof Iterator<?> itr) {
+                            itr.remove();
+                            return;
+                        }
+                        throw new UnsupportedOperationException();
+                    }
+                });
+
+                var iterable = new KuimiClass(this, Type.getType(Iterable.class), Opcodes.ACC_PUBLIC | Opcodes.ACC_INTERFACE, null, javaLangObject, null);
+                bootstrapPool.put(iterable);
+                iterable.getMethodTable().addMethod(new KuimiMethod(iterable, Opcodes.ACC_PUBLIC, "iterator", iterator, List.of()) {
+                    KuimiObject<?> execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof Iterable<?>) {
+                            var rsp = new KuimiObject<>(iterator);
+                            rsp.setDelegateInstance(((Iterable<?>) d).iterator());
+                            return rsp;
+                        }
+                        throw new UnsupportedOperationException();
+                    }
+                });
+
+                var collection = new KuimiClass(this, Type.getType(Collection.class), Opcodes.ACC_PUBLIC | Opcodes.ACC_INTERFACE, null, javaLangObject, List.of(iterable));
+                bootstrapPool.put(collection);
+                collection.getMethodTable().addMethod(new KuimiMethod(collection, Opcodes.ACC_PUBLIC, "size", getPrimitiveClass(Type.INT_TYPE), null) {
+                    int execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof Collection<?> itr) return itr.size();
+                        throw new UnsupportedOperationException();
+                    }
+                });
+                collection.getMethodTable().addMethod(new KuimiMethod(collection, Opcodes.ACC_PUBLIC, "isEmpty", getPrimitiveClass(Type.BOOLEAN_TYPE), null) {
+                    boolean execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof Collection<?> itr) return itr.isEmpty();
+                        throw new UnsupportedOperationException();
+                    }
+                });
+                collection.getMethodTable().addMethod(new KuimiMethod(collection, Opcodes.ACC_PUBLIC, "contains", getPrimitiveClass(Type.INT_TYPE), List.of(javaLangObject)) {
+                    boolean execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz, KuimiObject<?> other) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof Collection<?> itr) return itr.contains(other);
+                        throw new UnsupportedOperationException();
+                    }
+                });
+                collection.getMethodTable().addMethod(new KuimiMethod(collection, Opcodes.ACC_PUBLIC, "toArray", javaLangObject.arrayType(), null) {
+                    KuimiObject<?> execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz) {
+                        var d = thiz.getDelegateInstance();
+
+                        if (d instanceof Collection<?> itr) //noinspection SuspiciousToArrayCall
+                            return new KuimiArrays.ArrayObject(javaLangObject.arrayType(), itr.toArray(new KuimiObject[0]));
+
+                        throw new UnsupportedOperationException();
+                    }
+                });
+                collection.getMethodTable().addMethod(new KuimiMethod(collection, Opcodes.ACC_PUBLIC, "add", getPrimitiveClass(Type.BOOLEAN_TYPE), List.of(javaLangObject)) {
+                    boolean execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz, KuimiObject<?> other) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof Collection itr) return itr.add(other);
+                        throw new UnsupportedOperationException();
+                    }
+                });
+                collection.getMethodTable().addMethod(new KuimiMethod(collection, Opcodes.ACC_PUBLIC, "remove", getPrimitiveClass(Type.BOOLEAN_TYPE), List.of(javaLangObject)) {
+                    boolean execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz, KuimiObject<?> other) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof Collection itr) return itr.remove(other);
+                        throw new UnsupportedOperationException();
+                    }
+                });
+                collection.getMethodTable().addMethod(new KuimiMethod(collection, Opcodes.ACC_PUBLIC, "clear", getPrimitiveClass(Type.VOID_TYPE), List.of()) {
+                    void execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof Collection itr) {
+                            itr.clear();
+                            return;
+                        }
+                        throw new UnsupportedOperationException();
+                    }
+                });
+
+                var set = new KuimiClass(this, Type.getType(Set.class), Opcodes.ACC_PUBLIC | Opcodes.ACC_INTERFACE, null, javaLangObject, List.of(collection));
+                bootstrapPool.put(set);
+
+                var list = new KuimiClass(this, Type.getType(List.class), Opcodes.ACC_PUBLIC | Opcodes.ACC_INTERFACE, null, javaLangObject, List.of(collection));
+                list.getMethodTable().addMethod(new KuimiMethod(list, Opcodes.ACC_PUBLIC, "get", javaLangObject, List.of(getPrimitiveClass(Type.INT_TYPE))) {
+                    KuimiObject<?> execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz, int idx) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof List itr) {
+                            return (KuimiObject<?>) itr.get(idx);
+                        }
+                        throw new UnsupportedOperationException();
+                    }
+                });
+                list.getMethodTable().addMethod(new KuimiMethod(list, Opcodes.ACC_PUBLIC, "remove", javaLangObject, List.of(getPrimitiveClass(Type.INT_TYPE))) {
+                    KuimiObject<?> execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz, int idx) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof List itr) {
+                            return (KuimiObject<?>) itr.remove(idx);
+                        }
+                        throw new UnsupportedOperationException();
+                    }
+                });
+                list.getMethodTable().addMethod(new KuimiMethod(list, Opcodes.ACC_PUBLIC, "set", javaLangObject, List.of(getPrimitiveClass(Type.INT_TYPE), javaLangObject)) {
+                    KuimiObject<?> execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz, int idx, KuimiObject<?> val) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof List itr) {
+                            return (KuimiObject<?>) itr.set(idx, val);
+                        }
+                        throw new UnsupportedOperationException();
+                    }
+                });
+                list.getMethodTable().addMethod(new KuimiMethod(list, Opcodes.ACC_PUBLIC, "add", getPrimitiveClass(Type.VOID_TYPE), List.of(getPrimitiveClass(Type.INT_TYPE), javaLangObject)) {
+                    void execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz, int idx, KuimiObject<?> val) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof List itr) {
+                            itr.add(idx, val);
+                            return;
+                        }
+                        throw new UnsupportedOperationException();
+                    }
+                });
+
+                list.getMethodTable().addMethod(new KuimiMethod(list, Opcodes.ACC_PUBLIC, "indexOf", getPrimitiveClass(Type.INT_TYPE), List.of(javaLangObject)) {
+                    int execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz, KuimiObject<?> val) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof List itr) {
+                            return itr.indexOf(val);
+                        }
+                        throw new UnsupportedOperationException();
+                    }
+                });
+
+                list.getMethodTable().addMethod(new KuimiMethod(list, Opcodes.ACC_PUBLIC, "lastIndexOf", getPrimitiveClass(Type.INT_TYPE), List.of(javaLangObject)) {
+                    int execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz, KuimiObject<?> val) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof List itr) {
+                            return itr.lastIndexOf(val);
+                        }
+                        throw new UnsupportedOperationException();
+                    }
+                });
+                // todo: listIterator
+                list.getMethodTable().addMethod(new KuimiMethod(list, Opcodes.ACC_PUBLIC, "subList", list, List.of(getPrimitiveClass(Type.INT_TYPE), getPrimitiveClass(Type.INT_TYPE))) {
+                    KuimiObject<?> execute(KuimiVM vm, StackTrace stackTrace, KuimiObject<?> thiz, int from, int end) {
+                        var d = thiz.getDelegateInstance();
+                        if (d instanceof List itr) {
+                            var rsp = itr.subList(from, end);
+                            var obj = new KuimiObject<>(list);
+                            obj.setDelegateInstance(rsp);
+                            return obj;
+                        }
+                        throw new UnsupportedOperationException();
+                    }
+                });
+
+
+                var arrayList = new KuimiClass(this, Type.getType(ArrayList.class), Opcodes.ACC_PUBLIC, null, javaLangObject, List.of(list));
+                bootstrapPool.put(arrayList);
+                arrayList.getMethodTable().addMethod(new KuimiMethod(arrayList, Opcodes.ACC_PUBLIC, "<init>", getPrimitiveClass(Type.VOID_TYPE), List.of()) {
+                    void execute(KuimiVM vm, StackTrace trace, KuimiObject thiz) {
+                        thiz.setDelegateInstance(new ArrayList());
+                    }
+                });
+                arrayList.getMethodTable().addMethod(new KuimiMethod(arrayList, Opcodes.ACC_PUBLIC, "<init>", getPrimitiveClass(Type.VOID_TYPE), List.of(getPrimitiveClass(Type.INT_TYPE))) {
+                    void execute(KuimiVM vm, StackTrace trace, KuimiObject thiz, int size) {
+                        thiz.setDelegateInstance(new ArrayList(size));
+                    }
+                });
+
+                arrayList.getMethodTable().addMethod(new KuimiMethod(arrayList, Opcodes.ACC_PUBLIC, "<init>", getPrimitiveClass(Type.VOID_TYPE), List.of(collection)) {
+                    void execute(KuimiVM vm, StackTrace trace, KuimiObject thiz, KuimiObject mirror) {
+                        thiz.setDelegateInstance(new ArrayList((Collection) mirror.getDelegateInstance()));
+                    }
+                });
+            }
+        }
+    }
+
+
+    @Override
+    public KuimiClass getBaseClass() {
+        return javaLangObject;
+    }
+
+    @Override
+    public KuimiClass getClassClass() {
+        return javaLangClass;
+    }
+
+    @Override
+    public KuimiClass getStringClass() {
+        return javaLangString;
+    }
+
+    @Override
+    public KuimiClass getPrimitiveClass(Type type) {
+        var sort = type.getSort();
+        if (sort == Type.ARRAY || sort == Type.OBJECT) {
+            throw new IllegalArgumentException(type + " not a primitive class");
+        }
+
+
+        return bootstrapPool.resolve(type.getClassName());
+    }
+
+    @Override
+    public long objectPointerSize() {
+        return Long.BYTES;
+    }
+
+    @Override
+    public KuimiClass resolveClass(Type type) {
+        if (type.getSort() == Type.ARRAY) {
+            var dep = type.getElementType();
+            var dsize = type.getDimensions();
+            KuimiClass dclass;
+            if (dep.getSort() == Type.OBJECT) {
+                dclass = resolveClassImpl(dep);
+            } else {
+                dclass = getPrimitiveClass(dep);
+            }
+            if (dclass == null) return null;
+            while (dsize-- > 0) {
+                dclass = dclass.arrayType();
+            }
+            return dclass;
+        }
+        if (type.getSort() == Type.OBJECT) {
+            return resolveClassImpl(type);
+        }
+        return getPrimitiveClass(type);
+    }
+
+    protected KuimiClass resolveClassImpl(Type type) {
+        return bootstrapPool.resolve(type.getClassName());
+    }
+
+    @Override
+    public ObjectPool getGlobalPool() {
+        return globalPool;
+    }
+
+    @Override
+    public ObjectPool getWeakGlobalPool() {
+        return weakGlobalPool;
+    }
+
+    @Override
+    public KuimiObject<?> resolveObject(int ptr) {
+        if (ptr == 0) return null;
+
+        var pfix = ptr & ObjectPool.OBJECT_PREFIX;
+        var rem = ptr & ~ObjectPool.OBJECT_PREFIX;
+
+        if (pfix == ObjectPool.GLOBAL_OBJECT_PREFIX) {
+            return globalPool.getObject(rem);
+        }
+        if (pfix == ObjectPool.LOCAL_OBJECT_PREFIX) {
+            var tstack = THREAD_STACK_TRACE.get();
+            if (tstack == null) return null;
+
+            return tstack.resolve(ptr);
+        }
+        if (pfix == ObjectPool.WEAK_GLOBAL_OBJECT_PREFIX) {
+            return weakGlobalPool.getObject(rem);
+        }
+        return null;
+    }
+
+
+    @Override
+    public StackTrace getStackTrace() {
+        return THREAD_STACK_TRACE.get();
+    }
+
+    @Override
+    public void attachThread(StackTrace stackTrace) {
+        Objects.requireNonNull(stackTrace, "stackTrace");
+        var st = THREAD_STACK_TRACE.get();
+        if (st == null) {
+            THREAD_STACK_TRACE.set(stackTrace);
+            return;
+        }
+
+        if (st.getLocalFramePoint() == -1 && st.getStackTracePoint() == -1) {
+            THREAD_STACK_TRACE.set(stackTrace);
+            return;
+        }
+
+        throw new IllegalStateException("Thread was already attached and cannot be re-attach now");
+    }
+
+    @Override
+    public void detatchThread() {
+        var st = THREAD_STACK_TRACE.get();
+        if (st == null) {
+            return;
+        }
+
+        if (st.getLocalFramePoint() == -1 && st.getStackTracePoint() == -1) {
+            THREAD_STACK_TRACE.remove();
+            return;
+        }
+
+        throw new IllegalStateException("Current thread is not detachable");
+    }
+
+    public ClassPool getBootstrapPool() {
+        return bootstrapPool;
+    }
+}

src/main/java/com/kiliokuara/kuimivm/attributes/AttributeKey.java

@@ -0,0 +1,19 @@
+package com.kiliokuara.kuimivm.attributes;
+
+import java.util.function.Function;
+
+public class AttributeKey<O, T> {
+    private final String name;
+
+    final Function<O, T> valueComputer;
+
+    public AttributeKey(String name, Function<O, T> valueComputer) {
+        this.name = name;
+        this.valueComputer = valueComputer;
+    }
+
+    @Override
+    public String toString() {
+        return "Attribute[" + name + "]";
+    }
+}

src/main/java/com/kiliokuara/kuimivm/attributes/AttributeMap.java

@@ -0,0 +1,16 @@
+package com.kiliokuara.kuimivm.attributes;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+public class AttributeMap<O> extends ConcurrentHashMap<AttributeKey<? super O, ?>, Object> {
+    private final O owner;
+
+    public AttributeMap(O owner) {
+        this.owner = owner;
+    }
+
+    public <T> T attribute(AttributeKey<? super O, T> key) {
+        //noinspection unchecked
+        return (T) computeIfAbsent(key, k -> key.valueComputer.apply(owner));
+    }
+}

src/main/java/com/kiliokuara/kuimivm/execute/ObjectPool.java

@@ -0,0 +1,100 @@
+package com.kiliokuara.kuimivm.execute;
+
+// 0000 0000 0000 0000  0000 0000 0000 0000
+// [][     ] [                            ] offset
+//  |  |
+//  | Page
+// Type
+
+// Type:
+// 11: Global objects
+// 01: Local frame objects
+// 10: Weak global references
+
+import com.kiliokuara.kuimivm.KuimiClass;
+import com.kiliokuara.kuimivm.KuimiObject;
+import com.kiliokuara.kuimivm.KuimiVM;
+import org.objectweb.asm.Type;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+
+public class ObjectPool {
+
+    public static final int LOCAL_OBJECT_PREFIX = 0b0100_0000_0000_0000__0000_0000_0000_0000;
+    public static final int GLOBAL_OBJECT_PREFIX = 0b1100_0000_0000_0000__0000_0000_0000_0000;
+    public static final int WEAK_GLOBAL_OBJECT_PREFIX = 0b1000_0000_0000_0000__0000_0000_0000_0000;
+
+    public static final int OBJECT_PREFIX = 0b1100_0000_0000_0000__0000_0000_0000_0000;
+
+
+    final KuimiObject<?>[] objects;
+    volatile int objIndex; // first null start index
+
+    private static final VarHandle OBJ_INDEX, OBJ_MOD;
+
+    private final KuimiObject<?> OBJ_UPDATE_PLACEHOLDER;
+
+    static {
+        var lk = MethodHandles.lookup();
+        try {
+            OBJ_INDEX = lk.findVarHandle(ObjectPool.class, "objIndex", int.class).withInvokeExactBehavior();
+            OBJ_MOD = MethodHandles.arrayElementVarHandle(KuimiObject[].class).withInvokeExactBehavior();
+        } catch (Exception e) {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
+
+    public ObjectPool(KuimiVM vm, int size) {
+        objects = new KuimiObject[size];
+        OBJ_UPDATE_PLACEHOLDER = new KuimiClass(vm, Type.VOID_TYPE, 0, null, null, null);
+    }
+
+    public int addObject(KuimiObject<?> object) {
+        if (object == null) return -1;
+        while (true) {
+            var sv = objIndex;
+            if (objects[sv] == null) {
+                if (OBJ_MOD.compareAndSet(objects, sv, (KuimiObject<?>) null, OBJ_UPDATE_PLACEHOLDER)) {
+                    OBJ_MOD.setVolatile(objects, sv, object);
+
+                    OBJ_INDEX.compareAndSet(this, sv, sv + 1);
+
+                    return sv;
+                }
+            } else {
+                OBJ_INDEX.compareAndSet(this, sv, sv + 1);
+            }
+        }
+    }
+
+    public KuimiObject<?> removeObject(int index) {
+        if (index < 0) return null;
+        while (true) {
+            var obj = (KuimiObject<?>) OBJ_MOD.getVolatile(objects, index);
+            if (obj == null) return null;
+            if (obj == OBJ_UPDATE_PLACEHOLDER) continue;
+
+            if (OBJ_MOD.compareAndSet(objects, index, obj, OBJ_UPDATE_PLACEHOLDER)) {
+                OBJ_MOD.setVolatile(objects, index, (KuimiObject<?>) null);
+
+                while (true) {
+                    var cidx = objIndex;
+                    if (cidx < index) break;
+                    if (OBJ_INDEX.compareAndSet(this, cidx, index)) break;
+                }
+
+                return obj;
+            }
+        }
+    }
+
+    public KuimiObject<?> getObject(int index) {
+        while (true) {
+            var rsp = (KuimiObject<?>) OBJ_MOD.getVolatile(objects, index);
+            if (rsp == OBJ_UPDATE_PLACEHOLDER) continue;
+
+            return rsp;
+        }
+    }
+}

src/main/java/com/kiliokuara/kuimivm/execute/StackTrace.java

@@ -0,0 +1,146 @@
+package com.kiliokuara.kuimivm.execute;
+
+import com.kiliokuara.kuimivm.KuimiMethod;
+import com.kiliokuara.kuimivm.KuimiObject;
+
+import java.util.BitSet;
+
+public class StackTrace {
+
+    int stackPoint, localFramePoint, frameObjectPointer;
+
+    final KuimiMethod[] stackTrace$trace;
+    final int[] stackTrace$localFrameStart;
+
+    final KuimiObject<?>[] frameObjects;
+    final int[] localFrameObjectStackStart;
+
+    final BitSet localFrame$hasObjectDeletion;
+
+    public KuimiObject<?> throwable;
+
+    public StackTrace(int stackTraceSize, int maxFrames, int frameObjects) {
+        // 0x00_00_00_00
+
+        stackTrace$trace = new KuimiMethod[stackTraceSize];
+        stackTrace$localFrameStart = new int[stackTraceSize];
+        localFrameObjectStackStart = new int[maxFrames];
+        localFrame$hasObjectDeletion = new BitSet(maxFrames);
+        this.frameObjects = new KuimiObject[frameObjects];
+
+        stackPoint = -1;
+        localFramePoint = -1;
+        frameObjectPointer = -1;
+    }
+
+    public void enter(KuimiMethod method) {
+        stackPoint++;
+        stackTrace$trace[stackPoint] = method;
+        stackTrace$localFrameStart[stackPoint] = localFramePoint;
+    }
+
+    public void pushFrame() {
+        localFramePoint++;
+        localFrameObjectStackStart[localFramePoint] = frameObjectPointer;
+        localFrame$hasObjectDeletion.clear(localFramePoint);
+    }
+
+    public int pushObject(KuimiObject<?> object) {
+        if (object == null) return 0;
+        if (localFramePoint == -1) pushFrame();
+
+        if (localFrame$hasObjectDeletion.get(localFramePoint)) { // has object remove
+            var frameObjStart = localFrameObjectStackStart[localFramePoint];
+            for (int idx = frameObjStart + 1, ed = frameObjectPointer; idx <= ed; idx++) {
+                if (frameObjects[idx] == null) {
+                    frameObjects[idx] = object;
+                    return ObjectPool.LOCAL_OBJECT_PREFIX | idx;
+                }
+            }
+
+            // no empty slot found / empty slot was refilled
+            localFrame$hasObjectDeletion.clear(localFramePoint);
+        }
+
+        frameObjects[frameObjectPointer + 1] = object;
+        frameObjectPointer++;
+
+        return ObjectPool.LOCAL_OBJECT_PREFIX | frameObjectPointer;
+    }
+
+    public KuimiObject<?> deleteObject(int obj) {
+        { // prefix check
+            var prefix = obj & ObjectPool.OBJECT_PREFIX;
+            if (prefix != ObjectPool.LOCAL_OBJECT_PREFIX) {
+                throw new IllegalArgumentException("Object " + obj + "(0x" + Integer.toHexString(obj) + ") is not a local frame object.");
+            }
+        }
+
+        var idx = obj & ~ObjectPool.OBJECT_PREFIX;
+        if (localFramePoint == -1) return null; // ?
+
+        var frameObjStart = localFrameObjectStackStart[localFramePoint];
+        if (idx > frameObjStart) {
+            var rsp = frameObjects[idx];
+            frameObjects[idx] = null;
+            localFrame$hasObjectDeletion.set(localFramePoint, true);
+            return rsp;
+        } else { // out of current frame.
+            throw new IllegalStateException("Object " + obj + "(0x" + Integer.toHexString(obj) + ")<" + idx + "> out of current frame, current frame start= " + frameObjStart);
+        }
+    }
+
+    public KuimiObject<?> resolve(int obj) {
+        { // prefix check
+            var prefix = obj & ObjectPool.OBJECT_PREFIX;
+            if (prefix != ObjectPool.LOCAL_OBJECT_PREFIX) {
+                return null;
+            }
+        }
+
+        var idx = obj & ~ObjectPool.OBJECT_PREFIX;
+        if (idx <= frameObjectPointer) return frameObjects[idx];
+        return null;
+    }
+
+    public void popFrame() {
+        // todo: check stack trace
+        var fos = localFrameObjectStackStart[localFramePoint];
+        for (int i = fos + 1, ed = frameObjectPointer; i < ed; i++) {
+            frameObjects[i] = null;
+        }
+        frameObjectPointer = fos;
+        localFramePoint--;
+    }
+
+    public void leave() {
+        var stackTraceFrameStack = stackTrace$localFrameStart[stackPoint];
+        while (localFramePoint > stackTraceFrameStack) {
+            popFrame();
+        }
+        stackTrace$trace[stackPoint] = null;
+        stackPoint--;
+    }
+
+    public void leave(KuimiMethod method) {
+        if (stackTrace$trace[stackPoint] == method) {
+            leave();
+        } else {
+            throw new IllegalStateException();
+        }
+    }
+
+
+    public int getStackTracePoint() {
+        return stackPoint;
+    }
+
+    public int getLocalFramePoint() {
+        return localFramePoint;
+    }
+
+    public KuimiMethod getStackTraceMethod(int st) {
+        return stackTrace$trace[st];
+    }
+}
+

src/main/java/com/kiliokuara/kuimivm/objects/KuimiArrays.java

@@ -0,0 +1,100 @@
+package com.kiliokuara.kuimivm.objects;
+
+import com.kiliokuara.kuimivm.KuimiClass;
+import com.kiliokuara.kuimivm.KuimiObject;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+import java.util.HexFormat;
+import java.util.function.IntFunction;
+
+public class KuimiArrays {
+    public interface Array {
+        int length();
+    }
+
+    public static class ArrayObject extends KuimiObject<KuimiObject<?>[]> implements Array {
+
+        public ArrayObject(KuimiClass objectType, KuimiObject<?>[] data) {
+            super(objectType);
+            setDelegateInstance(data);
+        }
+
+        @Override
+        public int length() {
+            return getDelegateInstance().length;
+        }
+    }
+
+    public static class ArrayClass extends KuimiClass {
+
+        public ArrayClass(KuimiClass elmType) {
+            super(
+                    elmType.getVm(), Type.getType("[" + elmType.getClassType().getDescriptor()),
+                    Opcodes.ACC_PUBLIC,
+                    elmType.getClassLoader(),
+                    elmType.getVm().getBaseClass(),
+                    null
+            );
+        }
+
+        @Override
+        public boolean isArray() {
+            return true;
+        }
+
+        @Override
+        public boolean isPrimitive() {
+            return false;
+        }
+
+        @Override
+        public KuimiObject<?> allocateNewObject() {
+            throw new RuntimeException("Allocating a array directly is not allowed");
+        }
+
+        public KuimiObject<?> allocateArray(int size) {
+            return new ArrayObject(this, new KuimiObject[size]);
+        }
+    }
+
+    public static class PrimitiveArrayClass extends ArrayClass {
+
+        private final IntFunction<Object> arrayAllocator;
+
+        public PrimitiveArrayClass(KuimiClass elmType, IntFunction<Object> arrayAllocator) {
+            super(elmType);
+            this.arrayAllocator = arrayAllocator;
+        }
+
+        @Override
+        public KuimiObject<?> allocateArray(int size) {
+            return new PrimitiveArray<>(this, arrayAllocator.apply(size));
+        }
+    }
+
+    public static class PrimitiveArray<T> extends KuimiObject<T> implements Array {
+        public PrimitiveArray(KuimiClass objectType, T array) {
+            super(objectType);
+            setDelegateInstance(array);
+        }
+
+        @Override
+        public int length() {
+            return java.lang.reflect.Array.getLength(getDelegateInstance());
+        }
+
+        @Override
+        public String toString() {
+            var dobj = getDelegateInstance();
+            if (dobj instanceof byte[] barr) {
+                var sb = new StringBuilder()
+                        .append("byte[").append(barr.length).append("]@").append(hashCode()).append(": ");
+
+                HexFormat.ofDelimiter(" ").withUpperCase().formatHex(sb, barr);
+                return sb.toString();
+            }
+            return super.toString();
+        }
+    }
+}

src/main/java/com/kiliokuara/kuimivm/objects/KuimiString.java

@@ -0,0 +1,31 @@
+package com.kiliokuara.kuimivm.objects;
+
+import com.kiliokuara.kuimivm.KuimiObject;
+import com.kiliokuara.kuimivm.KuimiVM;
+
+public class KuimiString extends KuimiObject<String> {
+    public KuimiString(KuimiVM kuimiVM, String data) {
+        super(kuimiVM.getStringClass());
+        super.setDelegateInstance(data);
+    }
+
+    @Override
+    public String toString() {
+        return getDelegateInstance();
+    }
+
+    @Override
+    public void setDelegateInstance(String delegateInstance) {
+        throw new UnsupportedOperationException();
+    }
+
+
+    public void forceChangeValue(String value) {
+        super.setDelegateInstance(value);
+    }
+
+    @Override
+    public int hashCode() {
+        return getDelegateInstance().hashCode();
+    }
+}

src/main/java/com/kiliokuara/kuimivm/runtime/ArrayAccess.java

@@ -0,0 +1,30 @@
+package com.kiliokuara.kuimivm.runtime;
+
+import com.kiliokuara.kuimivm.KuimiClass;
+import com.kiliokuara.kuimivm.KuimiObject;
+
+public class ArrayAccess {
+    //@formatter:off
+    public static KuimiObject<?>    AALOAD(KuimiObject<?> array, int index) {return ((KuimiObject<?>[])     array.getDelegateInstance())[index];}
+    public static byte              BALOAD(KuimiObject<?> array, int index) {return ((byte[])               array.getDelegateInstance())[index];}
+    public static char              CALOAD(KuimiObject<?> array, int index) {return ((char[])               array.getDelegateInstance())[index];}
+    public static short             SALOAD(KuimiObject<?> array, int index) {return ((short[])              array.getDelegateInstance())[index];}
+    public static int               IALOAD(KuimiObject<?> array, int index) {return ((int[])                array.getDelegateInstance())[index];}
+    public static long              LALOAD(KuimiObject<?> array, int index) {return ((long[])               array.getDelegateInstance())[index];}
+    public static float             FALOAD(KuimiObject<?> array, int index) {return ((float[])              array.getDelegateInstance())[index];}
+    public static double            DALOAD(KuimiObject<?> array, int index) {return ((double[])             array.getDelegateInstance())[index];}
+
+    public static void AASTORE(KuimiObject<?> array, int index, KuimiObject<?> value) { ((KuimiObject<?>[]) array.getDelegateInstance())[index] = value;}
+    public static void BASTORE(KuimiObject<?> array, int index, byte value          ) { ((byte[])           array.getDelegateInstance())[index] = value;}
+    public static void CASTORE(KuimiObject<?> array, int index, char value          ) { ((char[])           array.getDelegateInstance())[index] = value;}
+    public static void SASTORE(KuimiObject<?> array, int index, short value         ) { ((short[])          array.getDelegateInstance())[index] = value;}
+    public static void IASTORE(KuimiObject<?> array, int index, int value           ) { ((int[])            array.getDelegateInstance())[index] = value;}
+    public static void LASTORE(KuimiObject<?> array, int index, long value          ) { ((long[])           array.getDelegateInstance())[index] = value;}
+    public static void FASTORE(KuimiObject<?> array, int index, float value         ) { ((float[])          array.getDelegateInstance())[index] = value;}
+    public static void DASTORE(KuimiObject<?> array, int index, double value        ) { ((double[])         array.getDelegateInstance())[index] = value;}
+    //@formatter:on
+
+    public static KuimiObject<?> newArray(int size, KuimiClass type) {
+        return type.arrayType().allocateArray(size);
+    }
+}

src/main/java/com/kiliokuara/kuimivm/runtime/ClassInitEnsure.java

@@ -0,0 +1,22 @@
+package com.kiliokuara.kuimivm.runtime;
+
+import com.kiliokuara.kuimivm.KuimiClass;
+import com.kiliokuara.kuimivm.KuimiField;
+import com.kiliokuara.kuimivm.KuimiMethod;
+
+public class ClassInitEnsure {
+    public static KuimiClass ensureInit(KuimiClass kuimiClass) {
+        kuimiClass.ensureClassInitialized();
+        return kuimiClass;
+    }
+
+    public static KuimiField ensureInit(KuimiField field) {
+        field.getDeclaredClass().ensureClassInitialized();
+        return field;
+    }
+
+    public static KuimiMethod ensureInit(KuimiMethod method) {
+        method.getDeclaredClass().ensureClassInitialized();
+        return method;
+    }
+}

src/main/java/com/kiliokuara/kuimivm/runtime/FieldAccessBridge.java

@@ -0,0 +1,120 @@
+package com.kiliokuara.kuimivm.runtime;
+
+import com.kiliokuara.kuimivm.KuimiField;
+import com.kiliokuara.kuimivm.KuimiObject;
+
+public class FieldAccessBridge {
+    public static KuimiObject<?> getobject(KuimiObject<?> object, KuimiField field) {
+        return object.memoryView().objects[field.getObjectIndex()];
+    }
+
+    public static boolean getboolean(KuimiObject<?> object, KuimiField field) {
+        return object.memoryView().buffer.get((int) field.getOffset()) != 0;
+    }
+
+    public static byte getbyte(KuimiObject<?> object, KuimiField field) {
+        return object.memoryView().buffer.get((int) field.getOffset());
+    }
+
+    public static short getshort(KuimiObject<?> object, KuimiField field) {
+        return object.memoryView().buffer.getShort((int) field.getOffset());
+    }
+
+    public static char getchar(KuimiObject<?> object, KuimiField field) {
+        return object.memoryView().buffer.getChar((int) field.getOffset());
+    }
+
+    public static int getint(KuimiObject<?> object, KuimiField field) {
+        return object.memoryView().buffer.getInt((int) field.getOffset());
+    }
+
+    public static long getlong(KuimiObject<?> object, KuimiField field) {
+        return object.memoryView().buffer.getLong((int) field.getOffset());
+    }
+
+    public static float getfloat(KuimiObject<?> object, KuimiField field) {
+        return object.memoryView().buffer.getFloat((int) field.getOffset());
+    }
+
+    public static double getdouble(KuimiObject<?> object, KuimiField field) {
+        return object.memoryView().buffer.getDouble((int) field.getOffset());
+    }
+
+    //
+
+    public static void put(KuimiObject<?> thiz, byte val, KuimiField field) {
+        thiz.memoryView().buffer.put((int) field.getOffset(), val);
+    }
+
+    public static void put(KuimiObject<?> thiz, short val, KuimiField field) {
+        thiz.memoryView().buffer.putShort((int) field.getOffset(), val);
+    }
+
+    public static void put(KuimiObject<?> thiz, char val, KuimiField field) {
+        thiz.memoryView().buffer.putChar((int) field.getOffset(), val);
+    }
+
+    public static void put(KuimiObject<?> thiz, int val, KuimiField field) {
+        thiz.memoryView().buffer.putInt((int) field.getOffset(), val);
+    }
+
+    public static void put(KuimiObject<?> thiz, long val, KuimiField field) {
+        thiz.memoryView().buffer.putLong((int) field.getOffset(), val);
+    }
+
+    public static void put(KuimiObject<?> thiz, boolean val, KuimiField field) {
+        thiz.memoryView().buffer.put((int) field.getOffset(), val ? (byte) 1 : 0);
+    }
+
+    public static void put(KuimiObject<?> thiz, float val, KuimiField field) {
+        thiz.memoryView().buffer.putFloat((int) field.getOffset(), val);
+    }
+
+    public static void put(KuimiObject<?> thiz, double val, KuimiField field) {
+        thiz.memoryView().buffer.putDouble((int) field.getOffset(), val);
+    }
+
+    public static void put(KuimiObject<?> thiz, KuimiObject<?> val, KuimiField field) {
+        thiz.memoryView().objects[field.getObjectIndex()] = val;
+    }
+
+
+    //
+
+    public static void put(byte val, KuimiField field) {
+        put(field.getDeclaredClass(), val, field);
+    }
+
+    public static void put(short val, KuimiField field) {
+        put(field.getDeclaredClass(), val, field);
+    }
+
+    public static void put(char val, KuimiField field) {
+        put(field.getDeclaredClass(), val, field);
+    }
+
+    public static void put(int val, KuimiField field) {
+        put(field.getDeclaredClass(), val, field);
+    }
+
+    public static void put(long val, KuimiField field) {
+        put(field.getDeclaredClass(), val, field);
+    }
+
+    public static void put(boolean val, KuimiField field) {
+        put(field.getDeclaredClass(), val, field);
+    }
+
+    public static void put(float val, KuimiField field) {
+        put(field.getDeclaredClass(), val, field);
+    }
+
+    public static void put(double val, KuimiField field) {
+        put(field.getDeclaredClass(), val, field);
+    }
+
+    public static void put(KuimiObject<?> val, KuimiField field) {
+        put(field.getDeclaredClass(), val, field);
+    }
+
+}

src/main/java/com/kiliokuara/kuimivm/transform/JarTransformer.java

@@ -0,0 +1,918 @@
+package com.kiliokuara.kuimivm.transform;
+
+import com.kiliokuara.kuimivm.*;
+import com.kiliokuara.kuimivm.abstractvm.ClassPool;
+import com.kiliokuara.kuimivm.execute.StackTrace;
+import com.kiliokuara.kuimivm.abstractvm.KuimiAbstractVM;
+import com.kiliokuara.kuimivm.objects.KuimiString;
+import com.kiliokuara.kuimivm.runtime.ArrayAccess;
+import com.kiliokuara.kuimivm.runtime.ClassInitEnsure;
+import com.kiliokuara.kuimivm.runtime.FieldAccessBridge;
+import com.kiliokuara.kuimivm.*;
+import org.objectweb.asm.*;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.util.Textifier;
+import org.objectweb.asm.util.TraceClassVisitor;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.lang.invoke.MethodHandle;
+import java.lang.reflect.Modifier;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.zip.ZipInputStream;
+
+
+@SuppressWarnings("DuplicatedCode")
+public class JarTransformer {
+    private static final Type KUIMI_VM = Type.getType(KuimiVM.class);
+    private static final Type STACK_TRACE = Type.getType(StackTrace.class);
+    private static final Type KUIMI_OBJECT = Type.getType(KuimiObject.class);
+    private static final Type KUIMI_CLASS = Type.getType(KuimiClass.class);
+    private static final Type KUIMI_FIELD = Type.getType(KuimiField.class);
+    private static final Type KUIMI_FIELD_TABLE = Type.getType(KuimiFieldTable.class);
+    private static final Type KUIMI_METHOD = Type.getType(KuimiMethod.class);
+    private static final Type KUIMI_METHOD_TABLE = Type.getType(KuimiMethodTable.class);
+    private static final Type ARRAY_ACCESS_BRIDGE = Type.getType(ArrayAccess.class);
+    private static final Type FIELD_ACCESS_BRIDGE = Type.getType(FieldAccessBridge.class);
+    private static final Type CLASS_INIT_ENSURE = Type.getType(ClassInitEnsure.class);
+    private static final Type TYPE = Type.getType(Type.class);
+    private static final Type STRING = Type.getType(String.class);
+
+
+    private final Map<String, ClassNode> classes;
+    private final Map<String, byte[]> output;
+    private boolean debug;
+
+    public JarTransformer(Map<String, ClassNode> classes) {
+        this.classes = classes;
+        output = new HashMap<>();
+    }
+
+    public JarTransformer() {
+        this(new HashMap<>());
+    }
+
+    public void merge(Map<String, ClassNode> classes) {
+        this.classes.putAll(classes);
+    }
+
+    public void loadFrom(ZipInputStream zipInputStream) throws IOException {
+        while (true) {
+            var entry = zipInputStream.getNextEntry();
+            if (entry == null) break;
+            if (!entry.getName().endsWith(".class")) continue;
+
+            var cr = new ClassNode();
+            new ClassReader(zipInputStream.readAllBytes()).accept(cr, 0);
+
+            classes.put(cr.name, cr);
+        }
+    }
+
+    public void setDebug(boolean debug) {
+        this.debug = debug;
+    }
+
+    protected void generateClassStructure_classRegister(MethodVisitor visitor) {
+        var absVM = Type.getType(KuimiAbstractVM.class).getInternalName();
+        visitor.visitVarInsn(Opcodes.ALOAD, 0);
+        visitor.visitTypeInsn(Opcodes.CHECKCAST, absVM);
+
+        var classPool = Type.getType(ClassPool.class);
+        visitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL, absVM, "getBootstrapPool", Type.getMethodDescriptor(classPool), false);
+
+        visitor.visitVarInsn(Opcodes.ALOAD, 1);
+        visitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL, classPool.getInternalName(), "put", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_CLASS), false);
+
+        visitor.visitInsn(Opcodes.RETURN);
+        visitor.visitMaxs(0, 0);
+        visitor.visitEnd();
+    }
+
+    private static void pushInt(MethodVisitor visitor, int value) {
+        if (value == -1) {
+            visitor.visitInsn(Opcodes.ICONST_M1);
+        } else if (value >= 0 && value <= 5) {
+            visitor.visitInsn(Opcodes.ICONST_0 + value);
+        } else if (value >= Byte.MIN_VALUE && value <= Byte.MAX_VALUE) {
+            visitor.visitIntInsn(Opcodes.BIPUSH, value);
+        } else if (value >= Short.MIN_VALUE && value <= Short.MAX_VALUE) {
+            visitor.visitIntInsn(Opcodes.SIPUSH, value);
+        } else {
+            visitor.visitLdcInsn(value);
+        }
+    }
+
+    public void generateClassStructure(Type outputName) {
+        if (outputName == null) {
+            outputName = Type.getObjectType("com/kiliokuara/kuimivm/transform/gen/" + UUID.randomUUID());
+        }
+        var outInternalName = outputName.getInternalName();
+
+
+        var classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+        classWriter.visit(Opcodes.V11, Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, outInternalName, null, "java/lang/Object", null);
+
+        {
+            var classRegister = classWriter.visitMethod(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC, "classRegister", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_VM, KUIMI_CLASS), null, null);
+            generateClassStructure_classRegister(classRegister);
+        }
+
+        {
+            // static KuimiClass loadClass(KuimiVM vm, String name, KuimiObject<?> classLoader)
+            var loadClass = classWriter.visitMethod(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC, "loadClass", Type.getMethodDescriptor(KUIMI_CLASS, KUIMI_VM, STRING, KUIMI_OBJECT), null, null);
+
+            {
+                loadClass.visitVarInsn(Opcodes.ALOAD, 0);
+                loadClass.visitVarInsn(Opcodes.ALOAD, 1);
+                loadClass.visitMethodInsn(Opcodes.INVOKESTATIC, TYPE.getInternalName(), "getObjectType", Type.getMethodDescriptor(TYPE, STRING), false);
+                loadClass.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_VM.getInternalName(), "resolveClass", Type.getMethodDescriptor(KUIMI_CLASS, TYPE), false);
+
+                var cont = new Label();
+                loadClass.visitInsn(Opcodes.DUP);
+                loadClass.visitJumpInsn(Opcodes.IFNULL, cont);
+                loadClass.visitInsn(Opcodes.ARETURN);
+
+                loadClass.visitLabel(cont);
+                loadClass.visitInsn(Opcodes.POP);
+            }
+
+            {
+                var hashCodeToString = new HashMap<Integer, Set<String>>();
+                var hashCodeToLabel = new HashMap<Integer, Label>();
+                var classNameToLabel = new HashMap<String, Label>();
+                var failLabel = new Label();
+
+                for (var klass : classes.values()) {
+                    var hcode = klass.name.hashCode();
+                    hashCodeToString.computeIfAbsent(hcode, $ -> new HashSet<>()).add(klass.name);
+                    classNameToLabel.put(klass.name, new Label());
+                }
+                for (var hcode : hashCodeToString.keySet()) {
+                    hashCodeToLabel.put(hcode, new Label());
+                }
+
+                loadClass.visitVarInsn(Opcodes.ALOAD, 1);
+                loadClass.visitMethodInsn(Opcodes.INVOKEVIRTUAL, STRING.getInternalName(), "hashCode", "()I", false);
+                {
+                    var tableLookupKeys = new int[hashCodeToLabel.size()];
+                    var tableLookupTargets = new Label[tableLookupKeys.length];
+                    var i = 0;
+                    for (var entry : hashCodeToLabel.entrySet().stream().sorted(Map.Entry.comparingByKey()).toList()) {
+                        tableLookupKeys[i] = entry.getKey();
+                        tableLookupTargets[i] = entry.getValue();
+                        i++;
+                    }
+                    loadClass.visitLookupSwitchInsn(failLabel, tableLookupKeys, tableLookupTargets);
+                }
+
+                for (var h2labelEntry : hashCodeToLabel.entrySet()) {
+                    loadClass.visitLabel(h2labelEntry.getValue());
+                    var strs = hashCodeToString.get(h2labelEntry.getKey());
+
+                    for (var str : strs) {
+                        loadClass.visitLdcInsn(str);
+                        loadClass.visitVarInsn(Opcodes.ALOAD, 1);
+                        loadClass.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/String", "equals", "(Ljava/lang/Object;)Z", false);
+                        loadClass.visitJumpInsn(Opcodes.IFNE, classNameToLabel.get(str));
+                    }
+                    loadClass.visitJumpInsn(Opcodes.GOTO, failLabel);
+                }
+
+                loadClass.visitLabel(failLabel);
+                loadClass.visitTypeInsn(Opcodes.NEW, "java/lang/UnsupportedOperationException");
+                loadClass.visitInsn(Opcodes.DUP);
+                loadClass.visitVarInsn(Opcodes.ALOAD, 1);
+                loadClass.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/UnsupportedOperationException", "<init>", "(Ljava/lang/String;)V", false);
+                loadClass.visitInsn(Opcodes.ATHROW);
+
+                for (var klass : classes.values()) {
+                    loadClass.visitLabel(classNameToLabel.get(klass.name));
+
+
+                    loadClass.visitTypeInsn(Opcodes.NEW, KUIMI_CLASS.getInternalName());
+                    loadClass.visitInsn(Opcodes.DUP);
+
+                    loadClass.visitVarInsn(Opcodes.ALOAD, 0);
+                    loadClass.visitLdcInsn(klass.name);
+                    loadClass.visitMethodInsn(Opcodes.INVOKESTATIC, TYPE.getInternalName(), "getObjectType", Type.getMethodDescriptor(TYPE, STRING), false);
+                    pushInt(loadClass, klass.access);
+                    loadClass.visitVarInsn(Opcodes.ALOAD, 2); // classLoader
+
+                    // parent class
+                    loadClass.visitVarInsn(Opcodes.ALOAD, 0);
+                    loadClass.visitLdcInsn(klass.superName);
+                    loadClass.visitVarInsn(Opcodes.ALOAD, 2);
+                    loadClass.visitMethodInsn(Opcodes.INVOKESTATIC, outInternalName, "loadClass", Type.getMethodDescriptor(KUIMI_CLASS, KUIMI_VM, STRING, KUIMI_OBJECT), false);
+
+                    // interfaces
+                    if (klass.interfaces == null || klass.interfaces.isEmpty()) {
+                        loadClass.visitMethodInsn(Opcodes.INVOKESTATIC, "java/util/List", "of", "()Ljava/util/List;", true);
+                    } else {
+                        loadClass.visitTypeInsn(Opcodes.NEW, "java/util/ArrayList");
+                        loadClass.visitInsn(Opcodes.DUP);
+                        loadClass.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/util/ArrayList", "<init>", "()V", false);
+
+                        for (var itf : klass.interfaces) {
+                            loadClass.visitInsn(Opcodes.DUP);
+
+                            loadClass.visitVarInsn(Opcodes.ALOAD, 0);
+                            loadClass.visitLdcInsn(itf);
+                            loadClass.visitVarInsn(Opcodes.ALOAD, 2);
+                            loadClass.visitMethodInsn(Opcodes.INVOKESTATIC, outInternalName, "loadClass", Type.getMethodDescriptor(KUIMI_CLASS, KUIMI_VM, STRING, KUIMI_OBJECT), false);
+
+                            loadClass.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/util/ArrayList", "add", "(Ljava/lang/Object;)Z", false);
+                            loadClass.visitInsn(Opcodes.POP);
+                        }
+                    }
+
+                    loadClass.visitMethodInsn(Opcodes.INVOKESPECIAL, KUIMI_CLASS.getInternalName(), "<init>", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_VM, TYPE, Type.INT_TYPE, KUIMI_OBJECT, KUIMI_CLASS, Type.getObjectType("java/util/List")), false);
+                    loadClass.visitInsn(Opcodes.DUP);
+
+                    loadClass.visitVarInsn(Opcodes.ALOAD, 0);
+                    loadClass.visitInsn(Opcodes.SWAP);
+
+                    loadClass.visitMethodInsn(Opcodes.INVOKESTATIC, outInternalName, "classRegister", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_VM, KUIMI_CLASS), false);
+
+                    loadClass.visitInsn(Opcodes.ARETURN);
+                }
+
+                loadClass.visitMaxs(0, 0);
+
+            }
+
+
+            var tool = new Object() {
+                public void resolveClass(MethodVisitor init, Type type) {
+                    init.visitVarInsn(Opcodes.ALOAD, 0);
+                    init.visitLdcInsn(type.getDescriptor());
+                    init.visitMethodInsn(Opcodes.INVOKESTATIC, TYPE.getInternalName(), "getType", Type.getMethodDescriptor(TYPE, STRING), false);
+                    init.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_VM.getInternalName(), "resolveClass", Type.getMethodDescriptor(KUIMI_CLASS, TYPE), false);
+                }
+
+                void directLoadClass(MethodVisitor init, String name) {
+
+                    init.visitVarInsn(Opcodes.ALOAD, 0);
+                    init.visitLdcInsn(name);
+                    init.visitVarInsn(Opcodes.ALOAD, 1);
+                    init.visitMethodInsn(Opcodes.INVOKESTATIC, outInternalName, "loadClass", Type.getMethodDescriptor(KUIMI_CLASS, KUIMI_VM, STRING, KUIMI_OBJECT), false);
+
+                }
+            };
+
+            // static void init(KuimiVM vm, KuimiObject<?> classLoader)
+            var init = classWriter.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "initialize", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_VM, KUIMI_OBJECT), null, null);
+            for (var klass : classes.values()) {
+                tool.directLoadClass(init, klass.name);
+                init.visitInsn(Opcodes.POP);
+            }
+
+            for (var kclass : classes.values()) {
+                tool.directLoadClass(init, kclass.name);
+
+                if (debug) {
+                    init.visitInsn(Opcodes.DUP);
+                    init.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+                    init.visitInsn(Opcodes.SWAP);
+                    init.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/Object;)V", false);
+                }
+
+                // @context: arg2 = <current-class>
+                init.visitInsn(Opcodes.DUP);
+                init.visitVarInsn(Opcodes.ASTORE, 2);
+
+                init.visitInsn(Opcodes.DUP); // for method table
+
+                // region fields
+                init.visitInsn(Opcodes.DUP);
+                init.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_CLASS.getInternalName(), "getFieldTable", Type.getMethodDescriptor(KUIMI_FIELD_TABLE), false);
+
+                for (var field : kclass.fields) {
+                    init.visitInsn(Opcodes.DUP);
+
+                    init.visitTypeInsn(Opcodes.NEW, KUIMI_FIELD.getInternalName());
+                    init.visitInsn(Opcodes.DUP);
+
+                    init.visitVarInsn(Opcodes.ALOAD, 2);// declared class
+                    pushInt(init, field.access);
+                    init.visitLdcInsn(field.name);
+                    tool.resolveClass(init, Type.getType(field.desc));
+                    init.visitMethodInsn(Opcodes.INVOKESPECIAL, KUIMI_FIELD.getInternalName(), "<init>", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_CLASS, Type.INT_TYPE, STRING, KUIMI_CLASS), false);
+
+                    if (debug) {
+                        init.visitInsn(Opcodes.DUP);
+                        init.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+                        init.visitLdcInsn("  |- Adding field ");
+                        init.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "append", "(Ljava/lang/CharSequence;)Ljava/io/PrintStream;", false);
+                        init.visitInsn(Opcodes.SWAP);
+                        init.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/Object;)V", false);
+                    }
+
+                    init.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_FIELD_TABLE.getInternalName(), "addField", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_FIELD), false);
+                }
+
+                init.visitInsn(Opcodes.POP); // pop field table
+                // endregion
+
+                init.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_CLASS.getInternalName(), "getMethodTable", Type.getMethodDescriptor(KUIMI_METHOD_TABLE), false);
+
+                for (var method : kclass.methods) {
+                    init.visitInsn(Opcodes.DUP);
+
+                    init.visitTypeInsn(Opcodes.NEW, KUIMI_METHOD.getInternalName());
+                    init.visitInsn(Opcodes.DUP);
+
+                    init.visitVarInsn(Opcodes.ALOAD, 2);// declared class
+                    pushInt(init, method.access);
+                    init.visitLdcInsn(method.name);
+                    tool.resolveClass(init, Type.getReturnType(method.desc));
+                    var params = Type.getArgumentTypes(method.desc);
+                    if (params.length == 0) {
+                        init.visitMethodInsn(Opcodes.INVOKESTATIC, "java/util/List", "of", "()Ljava/util/List;", true);
+                    } else {
+                        init.visitTypeInsn(Opcodes.NEW, "java/util/ArrayList");
+                        init.visitInsn(Opcodes.DUP);
+                        init.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/util/ArrayList", "<init>", "()V", false);
+
+                        for (var param : params) {
+                            init.visitInsn(Opcodes.DUP);
+                            tool.resolveClass(init, param);
+                            init.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/util/ArrayList", "add", "(Ljava/lang/Object;)Z", false);
+                            init.visitInsn(Opcodes.POP);
+                        }
+                    }
+                    init.visitMethodInsn(Opcodes.INVOKESPECIAL, KUIMI_METHOD.getInternalName(), "<init>", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_CLASS, Type.INT_TYPE, STRING, KUIMI_CLASS, Type.getType(List.class)), false);
+
+
+                    init.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_METHOD_TABLE.getInternalName(), "addMethod", Type.getMethodDescriptor(KUIMI_METHOD, KUIMI_METHOD), false);
+
+                    if (debug) {
+                        init.visitInsn(Opcodes.DUP);
+                        init.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+                        init.visitLdcInsn("  |- Adding method ");
+                        init.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "append", "(Ljava/lang/CharSequence;)Ljava/io/PrintStream;", false);
+                        init.visitInsn(Opcodes.SWAP);
+                        init.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/Object;)V", false);
+                    }
+                    if (method.instructions != null && method.instructions.size() > 0) {
+                        if (debug) {
+                            init.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
+                            init.visitLdcInsn("  |  `- Method code found");
+                            init.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/Object;)V", false);
+                        }
+
+                        var wcpName = generateMethod(method, kclass);
+                        var paramTypes = getParamsType(method);
+
+                        init.visitLdcInsn(new Handle(
+                                Opcodes.H_INVOKESTATIC, wcpName, "execute", Type.getMethodDescriptor(
+                                paramTypes.remove(0), paramTypes.toArray(Type[]::new)
+                        ), false));
+
+                        init.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_METHOD.getInternalName(), "attachImplementation", Type.getMethodDescriptor(KUIMI_METHOD, Type.getType(MethodHandle.class)), false);
+                    }
+                    init.visitInsn(Opcodes.POP);
+                }
+
+                init.visitInsn(Opcodes.POP); // pop method table
+
+            }
+
+            init.visitInsn(Opcodes.RETURN);
+            init.visitMaxs(0, 0);
+        }
+
+
+        output.put(outInternalName, classWriter.toByteArray());
+    }
+
+    public Map<String, byte[]> getOutput() {
+        return output;
+    }
+
+    private String generateMethod(MethodNode method, ClassNode kclass) {
+        var wcpName = kclass.name + "$met" + method.name.replace('<', '_').replace('>', '_');
+        {
+            var counter = 0;
+            var baseName = wcpName + '$';
+            while (output.containsKey(wcpName)) {
+                wcpName = baseName + counter;
+                counter++;
+            }
+        }
+
+        try {
+            var cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+
+            generateMethodImpl(method, cw, wcpName);
+
+            output.put(wcpName, cw.toByteArray());
+
+            return wcpName;
+        } catch (Throwable throwable) {
+            method.instructions.resetLabels();
+            var cw = new ClassWriter(0);
+
+            // TODO: output
+            generateMethodImpl(method, new TraceClassVisitor(cw, new Textifier(), new PrintWriter(System.out, true)), wcpName);
+
+            if (true) { // FIXME
+                var shorten = wcpName.substring(wcpName.lastIndexOf('/') + 1);
+                System.out.println(shorten);
+                try {
+                    Files.write(Path.of("B:/vmts", shorten + ".class"), cw.toByteArray());
+                } catch (IOException e) {
+                    throwable.addSuppressed(e);
+                    throw throwable;
+                }
+            }
+
+            output.put(wcpName, cw.toByteArray());
+
+            throw throwable;
+        }
+    }
+
+
+    private ArrayList<Type> getParamsType(MethodNode method) {
+        var mtdesc = Type.getMethodType(method.desc);
+
+        var params = new ArrayList<Type>();
+        params.add(mtdesc.getReturnType());
+        if (!Modifier.isStatic(method.access)) {
+            params.add(Type.getObjectType("java/lang/Object"));
+        }
+
+        params.addAll(List.of(mtdesc.getArgumentTypes()));
+        var kuimiObject = Type.getType(KuimiObject.class);
+
+        params.replaceAll(type -> {
+            var sort = type.getSort();
+            if (sort == Type.ARRAY || sort == Type.OBJECT) return kuimiObject;
+            return type;
+        });
+        // var rtType = params.remove(0);
+
+
+        params.add(1, Type.getType(KuimiVM.class));
+        params.add(2, Type.getType(StackTrace.class));
+
+        return params;
+    }
+
+    private void generateMethodImpl(MethodNode method, ClassVisitor cw, String wcpName) {
+        cw.visit(
+                Opcodes.V11,
+                Opcodes.ACC_PUBLIC,
+                wcpName,
+                null, "java/lang/Object", null
+        );
+
+        var params = getParamsType(method);
+        var rtType = params.remove(0);
+
+        cw.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC, "initialized", "Z", null, null);
+
+        var dataInit = cw.visitMethod(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC, "init", Type.getMethodDescriptor(
+                Type.VOID_TYPE, Type.getType(KuimiVM.class)
+        ), null, null);
+
+        var postDataInit = new MethodNode();
+
+
+        {
+            dataInit.visitFieldInsn(Opcodes.GETSTATIC, wcpName, "initialized", "Z");
+            var endLabel = new Label();
+            dataInit.visitJumpInsn(Opcodes.IFEQ, endLabel);
+            dataInit.visitInsn(Opcodes.RETURN);
+            dataInit.visitLabel(endLabel);
+            dataInit.visitFrame(Opcodes.F_SAME, 1, null, 0, null);
+        }
+
+        method.accept(new ClassVisitor(Opcodes.ASM9, cw) {
+            @Override
+            public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
+                var mv = super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "execute", Type.getMethodDescriptor(
+                        rtType, params.toArray(Type[]::new)
+                ), signature, exceptions);
+
+
+                var typeFieldMapping = new HashMap<String, String>() {
+                    String map(String type) {
+                        return map(Type.getObjectType(type));
+                    }
+
+                    String map(Type type) {
+                        var rsp = get(type.getDescriptor());
+                        if (rsp != null) return rsp;
+
+                        var name = "t" + size();
+                        cw.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC, name, KUIMI_CLASS.getDescriptor(), null, null);
+
+                        dataInit.visitVarInsn(Opcodes.ALOAD, 0);
+                        dataInit.visitLdcInsn(type.getDescriptor());
+                        dataInit.visitMethodInsn(Opcodes.INVOKESTATIC, TYPE.getInternalName(), "getType", Type.getMethodDescriptor(TYPE, STRING), false);
+                        dataInit.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_VM.getInternalName(), "resolveClass", Type.getMethodDescriptor(
+                                KUIMI_CLASS, TYPE
+                        ), false);
+                        dataInit.visitFieldInsn(Opcodes.PUTSTATIC, wcpName, name, KUIMI_CLASS.getDescriptor());
+
+                        put(type.getDescriptor(), name);
+                        return name;
+                    }
+
+                    void loadType(MethodVisitor mv, String name) {
+                        mv.visitFieldInsn(Opcodes.GETSTATIC, wcpName, map(name), KUIMI_CLASS.getDescriptor());
+                    }
+
+                    void loadType(MethodVisitor mv, Type type) {
+                        mv.visitFieldInsn(Opcodes.GETSTATIC, wcpName, map(type), KUIMI_CLASS.getDescriptor());
+                    }
+                };
+                var metMapping = new HashMap<String, String>() {
+                    String map(boolean isStatic, String owner, String name, String descriptor) {
+                        var key = isStatic + "-" + owner + "." + name + descriptor;
+                        var rsp = get(key);
+                        if (rsp != null) return rsp;
+
+                        rsp = "m" + size();
+
+
+                        cw.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC, rsp, KUIMI_METHOD.getDescriptor(), null, null);
+
+                        typeFieldMapping.loadType(postDataInit, owner);
+                        getMethodTable(postDataInit);
+
+                        postDataInit.visitLdcInsn(name);
+
+                        typeFieldMapping.loadType(postDataInit, Type.getReturnType(descriptor));
+
+                        postDataInit.visitTypeInsn(Opcodes.NEW, "java/util/ArrayList");
+                        postDataInit.visitInsn(Opcodes.DUP);
+                        postDataInit.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/util/ArrayList", "<init>", "()V", false);
+
+                        for (var param : Type.getArgumentTypes(descriptor)) {
+                            postDataInit.visitInsn(Opcodes.DUP);
+                            typeFieldMapping.loadType(postDataInit, param);
+                            postDataInit.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/util/ArrayList", "add", "(Ljava/lang/Object;)Z", false);
+                            postDataInit.visitInsn(Opcodes.POP);
+                        }
+
+                        postDataInit.visitInsn(isStatic ? Opcodes.ICONST_1 : Opcodes.ICONST_0);
+                        // public KuimiMethod resolveMethod(String name, KuimiClass retType, List<KuimiClass> params, boolean isStatic)
+
+                        postDataInit.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_METHOD_TABLE.getInternalName(), "resolveMethod", Type.getMethodDescriptor(
+                                KUIMI_METHOD, STRING, KUIMI_CLASS, Type.getType(List.class), Type.BOOLEAN_TYPE
+                        ), false);
+                        postDataInit.visitFieldInsn(Opcodes.PUTSTATIC, wcpName, rsp, KUIMI_METHOD.getDescriptor());
+
+                        put(key, rsp);
+                        return rsp;
+                    }
+
+                    void getMethodTable(MethodVisitor mv) {
+                        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_CLASS.getInternalName(), "getMethodTable", Type.getMethodDescriptor(KUIMI_METHOD_TABLE), false);
+                    }
+                };
+                var objMap = new HashMap<String, String>() {
+                    String ldcField(String value) {
+                        var rsp = get(value);
+                        if (rsp != null) return rsp;
+
+                        rsp = "str" + size();
+                        cw.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC, rsp, KUIMI_OBJECT.getDescriptor(), null, null);
+
+
+                        postDataInit.visitTypeInsn(Opcodes.NEW, Type.getType(KuimiString.class).getInternalName());
+                        postDataInit.visitInsn(Opcodes.DUP);
+                        postDataInit.visitVarInsn(Opcodes.ALOAD, 0);
+                        postDataInit.visitLdcInsn(value);
+                        postDataInit.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getType(KuimiString.class).getInternalName(), "<init>", Type.getMethodDescriptor(
+                                Type.VOID_TYPE, KUIMI_VM, STRING
+                        ), false);
+
+                        postDataInit.visitFieldInsn(Opcodes.PUTSTATIC, wcpName, rsp, KUIMI_OBJECT.getDescriptor());
+
+
+                        put(value, rsp);
+                        return rsp;
+                    }
+                };
+                var fieldAccessMap = new HashMap<String, String>() {
+                    String fieldField(String owner, String name, String type, boolean isStatic) {
+                        var key = isStatic + "." + owner + "." + name + ":" + type;
+                        var rsp = get(key);
+                        if (rsp != null) return rsp;
+
+                        rsp = "fd" + size();
+
+                        cw.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC, rsp, KUIMI_FIELD.getDescriptor(), null, null);
+
+                        typeFieldMapping.loadType(postDataInit, owner);
+                        postDataInit.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_CLASS.getInternalName(), "getFieldTable", Type.getMethodDescriptor(KUIMI_FIELD_TABLE), false);
+                        postDataInit.visitInsn(isStatic ? Opcodes.ICONST_1 : Opcodes.ICONST_0);
+                        postDataInit.visitLdcInsn(name);
+                        typeFieldMapping.loadType(postDataInit, Type.getType(type));
+                        postDataInit.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_FIELD_TABLE.getInternalName(), "findField", Type.getMethodDescriptor(
+                                KUIMI_FIELD, Type.BOOLEAN_TYPE, Type.getType(String.class), KUIMI_CLASS
+                        ), false);
+
+                        postDataInit.visitFieldInsn(Opcodes.PUTSTATIC, wcpName, rsp, KUIMI_FIELD.getDescriptor());
+
+                        put(key, rsp);
+                        return rsp;
+                    }
+                };
+
+                mv.visitVarInsn(Opcodes.ALOAD, 0);
+                mv.visitMethodInsn(Opcodes.INVOKESTATIC, wcpName, "init", Type.getMethodDescriptor(
+                        Type.VOID_TYPE, Type.getType(KuimiVM.class)
+                ), false);
+
+
+                return new MethodVisitor(api, mv) {
+
+                    private void loadType(String name) {
+                        typeFieldMapping.loadType(mv, name);
+                    }
+
+                    private void pushMethod(String fname) {
+                        mv.visitFieldInsn(Opcodes.GETSTATIC, wcpName, fname, KUIMI_METHOD.getDescriptor());
+                    }
+
+                    @Override
+                    public void visitVarInsn(int opcode, int varIndex) {
+                        super.visitVarInsn(opcode, varIndex + 2);
+                    }
+
+                    @Override
+                    public void visitIincInsn(int varIndex, int increment) {
+                        super.visitIincInsn(varIndex + 2, increment);
+                    }
+
+                    @Override
+                    public void visitLdcInsn(Object value) {
+                        if (value instanceof String str) {
+                            mv.visitFieldInsn(Opcodes.GETSTATIC, wcpName, objMap.ldcField(str), KUIMI_OBJECT.getDescriptor());
+                            return;
+                        }
+                        super.visitLdcInsn(value);
+                    }
+
+                    @Override
+                    public void visitInsn(int opcode) {
+                        if (opcode == Opcodes.ARRAYLENGTH) {
+                            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_OBJECT.getInternalName(), "getDelegateInstance", "()Ljava/lang/Object;", false);
+                            mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/reflect/Array", "getLength", "(Ljava/lang/Object;)I", false);
+                            return;
+                        }
+
+                        //@formatter:off
+                        if (opcode == Opcodes.AALOAD) {mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "AALOAD", Type.getMethodDescriptor(KUIMI_OBJECT, KUIMI_OBJECT, Type.INT_TYPE), false);return;}
+                        if (opcode == Opcodes.BALOAD) {mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "BALOAD", Type.getMethodDescriptor(Type.BYTE_TYPE, KUIMI_OBJECT, Type.INT_TYPE), false);return;}
+                        if (opcode == Opcodes.CALOAD) {mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "CALOAD", Type.getMethodDescriptor(Type.CHAR_TYPE, KUIMI_OBJECT, Type.INT_TYPE), false);return;}
+                        if (opcode == Opcodes.SALOAD) {mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "SALOAD", Type.getMethodDescriptor(Type.SHORT_TYPE, KUIMI_OBJECT, Type.INT_TYPE), false);return;}
+                        if (opcode == Opcodes.IALOAD) {mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "IALOAD", Type.getMethodDescriptor(Type.INT_TYPE, KUIMI_OBJECT, Type.INT_TYPE), false);return;}
+                        if (opcode == Opcodes.LALOAD) {mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "LALOAD", Type.getMethodDescriptor(Type.LONG_TYPE, KUIMI_OBJECT, Type.INT_TYPE), false);return;}
+                        if (opcode == Opcodes.FALOAD) {mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "FALOAD", Type.getMethodDescriptor(Type.FLOAT_TYPE, KUIMI_OBJECT, Type.INT_TYPE), false);return;}
+                        if (opcode == Opcodes.DALOAD) {mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "DALOAD", Type.getMethodDescriptor(Type.DOUBLE_TYPE, KUIMI_OBJECT, Type.INT_TYPE), false);return;}
+
+                        if (opcode == Opcodes.AASTORE){mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "AASTORE", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_OBJECT, Type.INT_TYPE, KUIMI_OBJECT), false);return;}
+                        if (opcode == Opcodes.BASTORE){mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "BASTORE", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_OBJECT, Type.INT_TYPE, Type.BYTE_TYPE), false);return;}
+                        if (opcode == Opcodes.CASTORE){mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "CASTORE", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_OBJECT, Type.INT_TYPE, Type.CHAR_TYPE), false);return;}
+                        if (opcode == Opcodes.SASTORE){mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "SASTORE", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_OBJECT, Type.INT_TYPE, Type.SHORT_TYPE), false);return;}
+                        if (opcode == Opcodes.IASTORE){mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "IASTORE", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_OBJECT, Type.INT_TYPE, Type.INT_TYPE), false);return;}
+                        if (opcode == Opcodes.LASTORE){mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "LASTORE", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_OBJECT, Type.INT_TYPE, Type.LONG_TYPE), false);return;}
+                        if (opcode == Opcodes.FASTORE){mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "FASTORE", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_OBJECT, Type.INT_TYPE, Type.FLOAT_TYPE), false);return;}
+                        if (opcode == Opcodes.DASTORE){mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "FASTORE", Type.getMethodDescriptor(Type.VOID_TYPE, KUIMI_OBJECT, Type.INT_TYPE, Type.DOUBLE_TYPE), false);return;}
+                        //@formatter:on
+
+                        super.visitInsn(opcode);
+                    }
+
+                    private void newArray(Type type) {
+                        typeFieldMapping.loadType(mv, type);
+                        mv.visitMethodInsn(Opcodes.INVOKESTATIC, ARRAY_ACCESS_BRIDGE.getInternalName(), "newArray", Type.getMethodDescriptor(KUIMI_OBJECT, Type.INT_TYPE, KUIMI_CLASS), false);
+                    }
+
+                    @Override
+                    public void visitIntInsn(int opcode, int operand) {
+                        if (opcode == Opcodes.NEWARRAY) {
+                            switch (operand) {
+                                case Opcodes.T_BOOLEAN -> newArray(Type.BOOLEAN_TYPE);
+                                case Opcodes.T_BYTE -> newArray(Type.BYTE_TYPE);
+                                case Opcodes.T_CHAR -> newArray(Type.CHAR_TYPE);
+                                case Opcodes.T_SHORT -> newArray(Type.SHORT_TYPE);
+                                case Opcodes.T_INT -> newArray(Type.INT_TYPE);
+                                case Opcodes.T_LONG -> newArray(Type.LONG_TYPE);
+                                case Opcodes.T_FLOAT -> newArray(Type.FLOAT_TYPE);
+                                case Opcodes.T_DOUBLE -> newArray(Type.DOUBLE_TYPE);
+                            }
+                            return;
+                        }
+                        super.visitIntInsn(opcode, operand);
+                    }
+
+                    @Override
+                    public void visitFieldInsn(int opcode, String owner, String name, String descriptor) {
+                        var isObj = descriptor.length() != 1;
+                        fieldAccessMap.fieldField(owner, name, descriptor, opcode == Opcodes.GETSTATIC || opcode == Opcodes.PUTSTATIC);
+
+                        var dstType = Type.getType(descriptor);
+                        var accessBridge = FIELD_ACCESS_BRIDGE;
+
+
+                        if (opcode == Opcodes.GETSTATIC) { // TODO
+                            typeFieldMapping.loadType(mv, owner);
+                        }
+                        if (opcode == Opcodes.GETSTATIC || opcode == Opcodes.GETFIELD) {
+                            mv.visitFieldInsn(Opcodes.GETSTATIC, wcpName, fieldAccessMap.fieldField(
+                                    owner, name, descriptor, opcode == Opcodes.GETSTATIC
+                            ), KUIMI_FIELD.getDescriptor());
+
+                            if (opcode == Opcodes.GETSTATIC) { // get object field don't need call init because class was initialized when object allocating
+                                mv.visitMethodInsn(Opcodes.INVOKESTATIC, CLASS_INIT_ENSURE.getInternalName(), "ensureInit", Type.getMethodDescriptor(KUIMI_FIELD, KUIMI_FIELD), false);
+                            }
+
+                            if (isObj) {
+                                mv.visitMethodInsn(Opcodes.INVOKESTATIC, accessBridge.getInternalName(), "getobject", Type.getMethodDescriptor(
+                                        KUIMI_OBJECT, KUIMI_OBJECT, KUIMI_FIELD
+                                ), false);
+                            } else {
+                                mv.visitMethodInsn(Opcodes.INVOKESTATIC, accessBridge.getInternalName(), "get" + dstType.getClassName(), Type.getMethodDescriptor(
+                                        dstType, KUIMI_OBJECT, KUIMI_FIELD
+                                ), false);
+                            }
+                        }
+
+                        if (opcode == Opcodes.PUTSTATIC) {
+                            mv.visitFieldInsn(Opcodes.GETSTATIC, wcpName, fieldAccessMap.fieldField(
+                                    owner, name, descriptor, true
+                            ), KUIMI_FIELD.getDescriptor());
+                            mv.visitMethodInsn(Opcodes.INVOKESTATIC, CLASS_INIT_ENSURE.getInternalName(), "ensureInit", Type.getMethodDescriptor(KUIMI_FIELD, KUIMI_FIELD), false);
+
+                            mv.visitMethodInsn(Opcodes.INVOKESTATIC, accessBridge.getInternalName(), "put", Type.getMethodDescriptor(
+                                    Type.VOID_TYPE, isObj ? KUIMI_OBJECT : dstType, KUIMI_FIELD
+                            ), false);
+                        }
+                        if (opcode == Opcodes.PUTFIELD) { // get object field don't need call init because class was initialized when object allocating
+                            mv.visitFieldInsn(Opcodes.GETSTATIC, wcpName, fieldAccessMap.fieldField(
+                                    owner, name, descriptor, false
+                            ), KUIMI_FIELD.getDescriptor());
+                            mv.visitMethodInsn(Opcodes.INVOKESTATIC, accessBridge.getInternalName(), "put", Type.getMethodDescriptor(
+                                    Type.VOID_TYPE, KUIMI_OBJECT, isObj ? KUIMI_OBJECT : dstType, KUIMI_FIELD
+                            ), false);
+                        }
+                        // super.visitFieldInsn(opcode, owner, name, descriptor);
+                    }
+
+                    @Override
+                    public void visitLocalVariable(String name, String descriptor, String signature, Label start, Label end, int index) {
+                        if ("this".equals(name)) {
+                            return;
+                        }
+                        super.visitLocalVariable(name, descriptor, signature, start, end, index + 2);
+                    }
+
+                    @Override
+                    public void visitMethodInsn(int opcode, String owner, String name, String descriptor, boolean isInterface) {
+                        var fname = metMapping.map(opcode == Opcodes.INVOKESTATIC, owner, name, descriptor);
+                        List<Type> args = new ArrayList<>(List.of(Type.getArgumentTypes(descriptor)));
+                        args.add(0, Type.getReturnType(descriptor));
+                        args.replaceAll(it -> {
+                            if (it.getSort() == Type.ARRAY || it.getSort() == Type.OBJECT) {
+                                return KUIMI_OBJECT;
+                            }
+                            return it;
+                        });
+
+
+                        if (opcode != Opcodes.INVOKESTATIC) {
+                            // reversedInvoke
+                            args.add(1, KUIMI_OBJECT);
+                        }
+
+                        pushMethod(fname);
+                        mv.visitVarInsn(Opcodes.ALOAD, 0);
+                        mv.visitVarInsn(Opcodes.ALOAD, 1);
+
+                        args.add(KUIMI_METHOD);
+                        args.add(KUIMI_VM);
+                        args.add(STACK_TRACE);
+
+                        var retType = args.remove(0);
+                        var mDesc = Type.getMethodDescriptor(retType, args.toArray(Type[]::new));
+
+                        var specialCall = opcode == Opcodes.INVOKESTATIC || opcode == Opcodes.INVOKESPECIAL;
+                        mv.visitMethodInsn(
+                                Opcodes.INVOKESTATIC, wcpName,
+                                specialCall ? "specialCall" : "call",
+                                mDesc, false
+                        );
+                        genWptCall(mDesc, retType, args, specialCall);
+                    }
+
+                    @Override
+                    public void visitTypeInsn(int opcode, String type) {
+                        if (opcode == Opcodes.NEW) {
+                            loadType(type);
+                            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_CLASS.getInternalName(), "allocateNewObject", Type.getMethodDescriptor(KUIMI_OBJECT), false);
+                            return;
+                        }
+                        if (opcode == Opcodes.CHECKCAST) {
+                            // TODO
+                            loadType(type);
+                            mv.visitInsn(Opcodes.POP);
+                            return;
+                        }
+                        if (opcode == Opcodes.ANEWARRAY) {
+                            newArray(Type.getObjectType(type));
+                            return;
+                        }
+                        super.visitTypeInsn(opcode, type);
+                    }
+
+                    private final HashSet<String> calls = new HashSet<>();
+
+                    void genWptCall(String desc, Type ret, List<Type> params, boolean specialCall) {
+                        if (!calls.add(specialCall + "." + desc)) return;
+
+                        var mtc = cw.visitMethod(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC, specialCall ? "specialCall" : "call", desc, null, null);
+                        int metSlot;
+
+                        var subl = params.subList(0, params.size() - 3);
+                        {
+                            var ix = 0;
+                            for (var p : subl) {
+                                ix += p.getSize();
+                            }
+                            metSlot = ix;
+                        }
+
+                        if (specialCall) {
+                            mtc.visitVarInsn(Opcodes.ALOAD, metSlot);
+                        } else {
+                            var mtTable = KUIMI_METHOD_TABLE;
+
+                            mtc.visitVarInsn(Opcodes.ALOAD, 0); // this
+                            mtc.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_OBJECT.getInternalName(), "getObjectClass", Type.getMethodDescriptor(KUIMI_CLASS), false);
+                            mtc.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_CLASS.getInternalName(), "getMethodTable", Type.getMethodDescriptor(mtTable), false);
+                            mtc.visitMethodInsn(Opcodes.INVOKEVIRTUAL, mtTable.getInternalName(), "getMergedMethods", "()Ljava/util/List;", false);
+
+                            mtc.visitVarInsn(Opcodes.ALOAD, metSlot);
+                            mtc.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_METHOD.getInternalName(), "getMethodSlot", "()I", false);
+
+                            mtc.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/util/List", "get", "(I)Ljava/lang/Object;", true);
+                            mtc.visitTypeInsn(Opcodes.CHECKCAST, KUIMI_METHOD.getInternalName());
+                        }
+
+                        mtc.visitMethodInsn(Opcodes.INVOKESTATIC, CLASS_INIT_ENSURE.getInternalName(), "ensureInit", Type.getMethodDescriptor(KUIMI_METHOD, KUIMI_METHOD), false);
+
+                        mtc.visitMethodInsn(Opcodes.INVOKEVIRTUAL, KUIMI_METHOD.getInternalName(), "resolveMethodHandle", "()Ljava/lang/invoke/MethodHandle;", false);
+
+
+                        mtc.visitVarInsn(Opcodes.ALOAD, metSlot + 1);
+                        mtc.visitVarInsn(Opcodes.ALOAD, metSlot + 2);
+                        var i = 0;
+                        for (var p : subl) {
+                            mtc.visitVarInsn(p.getOpcode(Opcodes.ILOAD), i);
+                            i += p.getSize();
+                        }
+
+                        var mhCallArgs = new ArrayList<>(subl);
+                        mhCallArgs.add(0, KUIMI_VM);
+                        mhCallArgs.add(1, STACK_TRACE);
+
+                        mtc.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/invoke/MethodHandle", "invokeExact",
+                                Type.getMethodDescriptor(ret, mhCallArgs.toArray(Type[]::new)),
+                                false
+                        );
+                        mtc.visitInsn(ret.getOpcode(Opcodes.IRETURN));
+
+                        mtc.visitMaxs(i + 4, i + 4);
+                        mtc.visitEnd();
+                    }
+                };
+            }
+        });
+
+        {
+            for (var insn : postDataInit.instructions) {
+                insn.accept(dataInit);
+            }
+
+            dataInit.visitInsn(Opcodes.ICONST_1);
+            dataInit.visitFieldInsn(Opcodes.PUTSTATIC, wcpName, "initialized", "Z");
+            dataInit.visitInsn(Opcodes.RETURN);
+            dataInit.visitMaxs(6, 4);
+            dataInit.visitEnd();
+        }
+
+        cw.visitEnd();
+
+    }
+
+}

src/main/java/com/kiliokuara/kuimivm/unidbg/ArmVarArg64Visitor.java

@@ -0,0 +1,45 @@
+package com.kiliokuara.kuimivm.unidbg;
+
+import com.github.unidbg.Emulator;
+import com.github.unidbg.pointer.UnidbgPointer;
+import com.kiliokuara.kuimivm.vaarg.ShortenType;
+import com.kiliokuara.kuimivm.vaarg.VaArgModelBuilder;
+import unicorn.Arm64Const;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.List;
+
+public class ArmVarArg64Visitor extends ArmVarArgVisitor {
+    public static void read(Emulator<?> emulator, VaArgModelBuilder output, List<ShortenType> shorties) {
+        int offset = 0;
+        int floatOff = 0;
+        for (var shorty : shorties) {
+            switch (shorty) {
+                case INT, REF -> {
+                    output.putInt(getInt(emulator, offset++));
+                }
+                case DOUBLE -> {
+                    output.putDouble(getVectorArg(emulator, floatOff++));
+                }
+                case FLOAT -> {
+                    output.putFloat((float) getVectorArg(emulator, floatOff++));
+                }
+                case LONG -> {
+                    UnidbgPointer ptr = getArg(emulator, offset++);
+                    output.putLong(ptr == null ? 0L : ptr.peer);
+                }
+                default -> throw new IllegalStateException("c=" + shorty);
+            }
+        }
+    }
+
+
+    private static double getVectorArg(Emulator<?> emulator, int index) {
+        ByteBuffer buffer = ByteBuffer.allocate(16);
+        buffer.order(ByteOrder.LITTLE_ENDIAN);
+        buffer.put(emulator.getBackend().reg_read_vector(Arm64Const.UC_ARM64_REG_Q0 + index));
+        buffer.flip();
+        return buffer.getDouble();
+    }
+}

src/main/java/com/kiliokuara/kuimivm/unidbg/ArmVarArgVisitor.java

@@ -0,0 +1,19 @@
+package com.kiliokuara.kuimivm.unidbg;
+
+import com.github.unidbg.Emulator;
+import com.github.unidbg.pointer.UnidbgPointer;
+
+public class ArmVarArgVisitor {
+    protected static final int REG_OFFSET = 3;
+
+
+    protected static UnidbgPointer getArg(Emulator<?> emulator, int index) {
+        return emulator.getContext().getPointerArg(REG_OFFSET + index);
+    }
+
+    protected static int getInt(Emulator<?> emulator, int index) {
+        UnidbgPointer ptr = getArg(emulator, index);
+        return ptr == null ? 0 : ptr.toIntPeer();
+    }
+
+}

src/main/java/com/kiliokuara/kuimivm/unidbg/JNIMemberTable.java

@@ -0,0 +1,62 @@
+package com.kiliokuara.kuimivm.unidbg;
+
+import com.kiliokuara.kuimivm.KuimiField;
+import com.kiliokuara.kuimivm.KuimiMember;
+import com.kiliokuara.kuimivm.KuimiMethod;
+import com.kiliokuara.kuimivm.attributes.AttributeKey;
+
+import java.util.Arrays;
+
+class JNIMemberTable {
+    private static final int BASE_OFFSET = 0x180;
+
+    private final AttributeKey<? super KuimiMember, SlotRecord> SLOT_RECORD = new AttributeKey<>("slot-record", it -> new SlotRecord(push(it)));
+
+    private KuimiMember[] members = new KuimiMember[256];
+    private volatile int pushSlotStart;
+
+    public KuimiMember resolve(int mid) {
+        if (mid < BASE_OFFSET) return null;
+        return members[mid - BASE_OFFSET];
+    }
+
+    public synchronized int push(KuimiMember member) {
+        if (member == null) return 0;
+
+        var mems = members;
+        for (int i = pushSlotStart, ed = mems.length; i < ed; i++) {
+            if (mems[i] == null) {
+                pushSlotStart = i + 1;
+                mems[i] = member;
+                return i + BASE_OFFSET;
+            }
+        }
+
+        members = Arrays.copyOf(mems, mems.length + 256);
+        return push(member);
+    }
+
+    public synchronized void drop(int slot) {
+        slot -= BASE_OFFSET;
+
+        var old = members[slot];
+        members[slot] = null;
+        if (old != null) {
+            old.getAttributeMap().remove(SLOT_RECORD);
+        }
+    }
+
+    public int getMemberId(KuimiMember member) {
+        return member.getAttributeMap().attribute(SLOT_RECORD).slot;
+    }
+
+    public KuimiMethod resolveMethodId(int peer) {
+        return (KuimiMethod) resolve(peer);
+    }
+    public KuimiField resolveFieldId(int peer){
+        return (KuimiField) resolve(peer);
+    }
+
+    record SlotRecord(int slot) {
+    }
+}

src/main/java/com/kiliokuara/kuimivm/unidbg/JValueListVisitor.java

@@ -0,0 +1,56 @@
+package com.kiliokuara.kuimivm.unidbg;
+
+import com.github.unidbg.Emulator;
+import com.github.unidbg.pointer.UnidbgPointer;
+import com.kiliokuara.kuimivm.vaarg.VaArgModelBuilder;
+import com.kiliokuara.kuimivm.KuimiClass;
+import com.sun.jna.Pointer;
+import org.objectweb.asm.Type;
+
+import java.util.List;
+
+public class JValueListVisitor {
+    public static void read(Emulator<?> emulator, UnidbgPointer jvalue, VaArgModelBuilder output, List<KuimiClass> params) {
+
+        Pointer pointer = jvalue;
+        for (var param : params) {
+            switch (param.getClassType().getSort()) {
+                case Type.OBJECT, Type.ARRAY -> {
+                    UnidbgPointer ptr = (UnidbgPointer) pointer.getPointer(0);
+                    output.putInt(ptr == null ? 0 : (int) ptr.toUIntPeer());
+                }
+                case Type.BYTE -> {
+                    byte val = pointer.getByte(0);
+                    output.putInt(val & 0xff);
+                }
+                case Type.BOOLEAN -> {
+                    byte val = pointer.getByte(0);
+                    output.putInt(val & 1);
+                }
+                case Type.CHAR -> {
+                    char val = pointer.getChar(0);
+                    output.putInt(val);
+                }
+                case Type.SHORT -> {
+                    output.putInt(pointer.getShort(0));
+                }
+                case Type.INT -> {
+                    output.putInt(pointer.getInt(0));
+                }
+                case Type.FLOAT -> {
+                    output.putFloat((float) pointer.getDouble(0));
+                }
+                case Type.DOUBLE -> {
+                    output.putDouble(pointer.getDouble(0));
+                }
+                case Type.LONG -> {
+                    output.putLong(pointer.getLong(0));
+                }
+                default -> throw new IllegalStateException("c=" + param);
+            }
+
+            pointer = pointer.share(8);
+        }
+
+    }
+}

src/main/java/com/kiliokuara/kuimivm/unidbg/KuimiJniMethodHandle.java

@@ -0,0 +1,172 @@
+package com.kiliokuara.kuimivm.unidbg;
+
+import com.github.unidbg.Module;
+import com.kiliokuara.kuimivm.execute.StackTrace;
+import com.kiliokuara.kuimivm.KuimiMethod;
+import com.kiliokuara.kuimivm.KuimiObject;
+import com.kiliokuara.kuimivm.KuimiVM;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+
+public class KuimiJniMethodHandle {
+    private static final MethodHandle ARRAY_LIST_NEW;
+    private static final MethodHandle ARRAY_LIST_ADD;
+    private static final MethodHandle NUMBER_LONG_VALUE;
+    private static final MethodHandle NUMBER_INT_VALUE;
+    private static final MethodHandle NUMBER_SHORT_VALUE;
+    private static final MethodHandle NUMBER_BYTE_VALUE;
+    private static final MethodHandle FLOAT_INT_BITS_TO_FLOAT;
+    private static final MethodHandle DOUBLE_LONG_BITS_TO_DOUBLE;
+
+
+    private static final MethodHandle KUIMI_VM_RESOLVE_OBJECT;
+
+
+    private static final MethodHandle N2C, N2B;
+    private static final MethodHandle RE_INVOKE;
+
+    static {
+        var lk = MethodHandles.lookup();
+        try {
+            ARRAY_LIST_NEW = lk.findConstructor(ArrayList.class, MethodType.methodType(void.class));
+            ARRAY_LIST_ADD = MethodHandles.dropReturn(lk.findVirtual(ArrayList.class, "add", MethodType.methodType(boolean.class, Object.class)));
+
+            NUMBER_LONG_VALUE = lk.findVirtual(Number.class, "longValue", MethodType.methodType(long.class));
+            NUMBER_INT_VALUE = lk.findVirtual(Number.class, "intValue", MethodType.methodType(int.class));
+            NUMBER_SHORT_VALUE = lk.findVirtual(Number.class, "shortValue", MethodType.methodType(short.class));
+            NUMBER_BYTE_VALUE = lk.findVirtual(Number.class, "byteValue", MethodType.methodType(byte.class));
+            FLOAT_INT_BITS_TO_FLOAT = lk.findStatic(Float.class, "intBitsToFloat", MethodType.methodType(float.class, int.class));
+            DOUBLE_LONG_BITS_TO_DOUBLE = lk.findStatic(Double.class, "longBitsToDouble", MethodType.methodType(double.class, long.class));
+
+            KUIMI_VM_RESOLVE_OBJECT = lk.findVirtual(KuimiVM.class, "resolveObject", MethodType.methodType(KuimiObject.class, int.class));
+
+            RE_INVOKE = lk.findStatic(KuimiJniMethodHandle.class, "reinvoke", MethodType.methodType(Number.class, KuimiUnidbgVM.class, KuimiMethod.class, long.class, ArrayList.class));
+            N2C = lk.findStatic(KuimiJniMethodHandle.class, "n2c", MethodType.methodType(char.class, Number.class));
+            N2B = lk.findStatic(KuimiJniMethodHandle.class, "n2b", MethodType.methodType(boolean.class, Number.class));
+
+
+        } catch (Throwable throwable) {
+            throw new ExceptionInInitializerError(throwable);
+        }
+    }
+
+    private static char n2c(Number i) {
+        return (char) i.intValue();
+    }
+
+    private static boolean n2b(Number i) {
+        return i.intValue() != 0;
+    }
+
+    private static Number reinvoke(KuimiUnidbgVM vm, KuimiMethod method, long peer, ArrayList<?> args) {
+        var st = (StackTrace) args.get(1);
+        var isStatic = Modifier.isStatic(method.getModifiers());
+        Object[] nativeArgs = new Object[isStatic ? args.size() : args.size() - 1];
+        nativeArgs[0] = vm.getJNIEnv();
+        int argIndex;
+        if (isStatic) {
+            nativeArgs[1] = st.pushObject(method.getDeclaredClass());
+            argIndex = 2;
+        } else {
+            argIndex = 1;
+        }
+
+        args.remove(0); // KuimiVM
+        args.remove(0); // StackTrace
+
+        for (var arg : args) {
+            if (arg instanceof Boolean bool) {
+                nativeArgs[argIndex++] = bool ? VMConst.JNI_TRUE : VMConst.JNI_FALSE;
+            } else if (arg instanceof KuimiObject<?> kobj) {
+                nativeArgs[argIndex++] = st.pushObject(kobj);
+            } else if (arg instanceof Number) {
+                nativeArgs[argIndex++] = arg;
+            } else {
+                nativeArgs[argIndex++] = arg;
+            }
+        }
+
+        var rsp = Module.emulateFunction(vm.emulator, peer, nativeArgs);
+        if (st.throwable != null) return 0;
+        return rsp;
+    }
+
+    public static MethodHandle invoker(
+            KuimiMethod targetMethod,
+            KuimiUnidbgVM vm,
+            long peer
+    ) {
+        //(KuimiVM, StackTrace, <KuimiObject>, .....)R
+        var mtType = targetMethod.flattenMethodHandleType();
+
+        // (ArrayList, KuimiVM, ArrayList, StackTrace, .....)V
+        MethodHandle emptyModel = MethodHandles.identity(ArrayList.class);
+        {
+            var ptList = mtType.parameterList();
+            for (var i = ptList.size() - 1; i >= 0; i--) {
+                emptyModel = MethodHandles.collectArguments(emptyModel, 1, ARRAY_LIST_ADD);
+            }
+        }
+
+        {
+            var mpx = new ArrayList<Class<?>>();
+            mpx.add(ArrayList.class);
+            for (var ignored : mtType.parameterList()) {
+                mpx.add(Object.class);
+            }
+
+            var newType = MethodType.methodType(ArrayList.class, mpx);
+            int[] slots = new int[emptyModel.type().parameterCount()];
+            for (var i = 0; i < mtType.parameterCount(); i++) {
+                slots[i * 2 + 2] = i + 1;
+            }
+
+            emptyModel = MethodHandles.permuteArguments(emptyModel, newType, slots);
+
+            mpx.clear();
+            mpx.add(ArrayList.class);
+            mpx.addAll(mtType.parameterList());
+            emptyModel = emptyModel.asType(MethodType.methodType(ArrayList.class, mpx));
+
+            emptyModel = MethodHandles.collectArguments(emptyModel, 0, ARRAY_LIST_NEW);
+        }
+        // emptyModel = ArgumentCollector
+        var reinvoker = MethodHandles.insertArguments(RE_INVOKE, 0, vm, targetMethod, peer);
+
+        emptyModel = MethodHandles.filterReturnValue(emptyModel, reinvoker);
+
+        var rspType = mtType.returnType();
+        if (rspType == void.class) {
+            emptyModel = MethodHandles.dropReturn(emptyModel);
+        } else if (rspType == long.class) {
+            emptyModel = MethodHandles.filterReturnValue(emptyModel, NUMBER_LONG_VALUE);
+        } else if (rspType == int.class) {
+            emptyModel = MethodHandles.filterReturnValue(emptyModel, NUMBER_INT_VALUE);
+        } else if (rspType == short.class) {
+            emptyModel = MethodHandles.filterReturnValue(emptyModel, NUMBER_SHORT_VALUE);
+        } else if (rspType == byte.class) {
+            emptyModel = MethodHandles.filterReturnValue(emptyModel, NUMBER_BYTE_VALUE);
+        } else if (rspType == char.class) {
+            emptyModel = MethodHandles.filterReturnValue(emptyModel, N2C);
+        } else if (rspType == boolean.class) {
+            emptyModel = MethodHandles.filterReturnValue(emptyModel, N2B);
+        } else if (rspType == KuimiObject.class) {
+            emptyModel = MethodHandles.filterReturnValue(emptyModel, NUMBER_INT_VALUE);
+            emptyModel = MethodHandles.filterReturnValue(emptyModel, KUIMI_VM_RESOLVE_OBJECT.bindTo(vm.vm));
+        } else if (rspType == float.class) {
+            emptyModel = MethodHandles.filterReturnValue(emptyModel, NUMBER_INT_VALUE);
+            emptyModel = MethodHandles.filterReturnValue(emptyModel, FLOAT_INT_BITS_TO_FLOAT);
+        } else if (rspType == double.class) {
+            emptyModel = MethodHandles.filterReturnValue(emptyModel, NUMBER_LONG_VALUE);
+            emptyModel = MethodHandles.filterReturnValue(emptyModel, DOUBLE_LONG_BITS_TO_DOUBLE);
+        } else {
+            throw new IllegalArgumentException("Unknown how to convert to " + rspType);
+        }
+
+        return emptyModel;
+    }
+}

src/main/java/com/kiliokuara/kuimivm/unidbg/KuimiUnidbgObjectMemory.java

@@ -0,0 +1,139 @@
+package com.kiliokuara.kuimivm.unidbg;
+
+import com.github.unidbg.memory.MemoryBlock;
+import com.github.unidbg.pointer.UnidbgPointer;
+import com.kiliokuara.kuimivm.KuimiObject;
+import com.sun.jna.Pointer;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+public class KuimiUnidbgObjectMemory {
+    private final KuimiUnidbgVM vm;
+    MemoryBlock memoryBlock;
+
+    KuimiUnidbgObjectMemory(KuimiUnidbgVM vm) {
+        this.vm = vm;
+    }
+
+    public UnidbgPointer allocateMemoryBlock(int length) {
+        if (memoryBlock != null) return memoryBlock.getPointer();
+        synchronized (this) {
+            if (memoryBlock != null) return memoryBlock.getPointer();
+
+            return (memoryBlock = vm.emulator.getMemory().malloc(length, true)).getPointer();
+        }
+    }
+
+    public void freeMemoryBlock(Pointer pointer) {
+        if (memoryBlock != null) {
+            synchronized (this) {
+                if (memoryBlock == null) return;
+
+                if (pointer != null && !memoryBlock.isSame(pointer)) return;
+
+                memoryBlock.free();
+                memoryBlock = null;
+            }
+        }
+    }
+
+    public long arrayCritical(KuimiObject<?> arrx) {
+        var arrObj = arrx.getDelegateInstance();
+
+        if (arrObj instanceof boolean[] d) {
+            var memory = allocateMemoryBlock(d.length);
+            for (var i = 0; i < d.length; i++) {
+                memory.setByte(i, d[i] ? (byte) 1 : 0);
+            }
+            return memory.peer;
+        }
+        if (arrObj instanceof byte[] d) {
+            var memory = allocateMemoryBlock(d.length);
+            memory.write(d);
+            return memory.peer;
+        }
+        if (arrObj instanceof char[] d) {
+            var memory = allocateMemoryBlock(d.length * 2);
+            var wp = ByteBuffer.allocate(d.length * 2);
+            wp.order(ByteOrder.LITTLE_ENDIAN).asCharBuffer().put(d);
+            memory.write(wp.array());
+            return memory.peer;
+        }
+        if (arrObj instanceof short[] d) {
+            var memory = allocateMemoryBlock(d.length * 2);
+            var wp = ByteBuffer.allocate(d.length * 2);
+            wp.order(ByteOrder.LITTLE_ENDIAN).asShortBuffer().put(d);
+            memory.write(wp.array());
+            return memory.peer;
+        }
+        if (arrObj instanceof int[] d) {
+            var memory = allocateMemoryBlock(d.length * 4);
+            var wp = ByteBuffer.allocate(d.length * 4);
+            wp.order(ByteOrder.LITTLE_ENDIAN).asIntBuffer().put(d);
+            memory.write(wp.array());
+            return memory.peer;
+        }
+        if (arrObj instanceof long[] d) {
+            var memory = allocateMemoryBlock(d.length * 8);
+            var wp = ByteBuffer.allocate(d.length * 8);
+            wp.order(ByteOrder.LITTLE_ENDIAN).asLongBuffer().put(d);
+            memory.write(wp.array());
+            return memory.peer;
+        }
+        if (arrObj instanceof float[] d) {
+            var memory = allocateMemoryBlock(d.length * Float.BYTES);
+            var wp = ByteBuffer.allocate(d.length * Float.BYTES);
+            wp.order(ByteOrder.LITTLE_ENDIAN).asFloatBuffer().put(d);
+            memory.write(wp.array());
+            return memory.peer;
+        }
+        if (arrObj instanceof double[] d) {
+            var memory = allocateMemoryBlock(d.length * Double.BYTES);
+            var wp = ByteBuffer.allocate(d.length * Double.BYTES);
+            wp.order(ByteOrder.LITTLE_ENDIAN).asDoubleBuffer().put(d);
+            memory.write(wp.array());
+            return memory.peer;
+        }
+        throw new IllegalArgumentException(arrx.toString());
+    }
+
+    @SuppressWarnings({"rawtypes", "UnnecessaryLocalVariable", "unchecked"})
+    public void arrayCriticalRelease(KuimiObject<?> obj, Pointer pointer, int mode) {
+        if (mode == VMConst.JNI_ABORT) {
+            freeMemoryBlock(pointer);
+            return;
+        }
+        KuimiObject objRaw = obj;
+        if (mode == VMConst.JNI_COMMIT || mode == 0) {
+            var arrObj = obj.getDelegateInstance();
+
+            if (arrObj instanceof boolean[] d) {
+                for (var i = 0; i < d.length; i++) {
+                    d[i] = pointer.getByte(i) != 0;
+                }
+            } else if (arrObj instanceof byte[] d) {
+                objRaw.setDelegateInstance(pointer.getByteArray(0, d.length));
+            } else if (arrObj instanceof char[] d) {
+                var buf = pointer.getByteBuffer(0, d.length * 2L);
+                buf.asCharBuffer().get(d);
+            } else if (arrObj instanceof short[] d) {
+                var buf = pointer.getByteBuffer(0, d.length * 2L);
+                buf.asShortBuffer().get(d);
+            } else if (arrObj instanceof int[] d) {
+                objRaw.setDelegateInstance(pointer.getIntArray(0, d.length));
+            } else if (arrObj instanceof long[] d) {
+                objRaw.setDelegateInstance(pointer.getLongArray(0, d.length));
+            } else if (arrObj instanceof float[] d) {
+                objRaw.setDelegateInstance(pointer.getFloatArray(0, d.length));
+            } else if (arrObj instanceof double[] d) {
+                objRaw.setDelegateInstance(pointer.getDoubleArray(0, d.length));
+            } else {
+                throw new IllegalArgumentException(obj.toString());
+            }
+        }
+        if (mode == 0) {
+            freeMemoryBlock(pointer);
+        }
+    }
+}

src/main/java/com/kiliokuara/kuimivm/unidbg/KuimiUnidbgVM.java

@@ -0,0 +1,27 @@
+package com.kiliokuara.kuimivm.unidbg;
+
+import com.github.unidbg.AndroidEmulator;
+import com.kiliokuara.kuimivm.KuimiObject;
+import com.kiliokuara.kuimivm.KuimiVM;
+import com.kiliokuara.kuimivm.attributes.AttributeKey;
+import com.sun.jna.Pointer;
+
+public abstract class KuimiUnidbgVM {
+    public final KuimiVM vm;
+    public final AndroidEmulator emulator;
+    public boolean verbose;
+
+    final AttributeKey<KuimiObject<?>, KuimiUnidbgObjectMemory> MEMORY = new AttributeKey<>("unidbg-memory", o -> new KuimiUnidbgObjectMemory(this));
+    final JNIMemberTable jniMemberTable = new JNIMemberTable();
+
+    public KuimiUnidbgVM(KuimiVM vm, AndroidEmulator emulator) {
+        this.vm = vm;
+        this.emulator = emulator;
+    }
+
+
+    public abstract Pointer getJavaVM();
+
+    public abstract Pointer getJNIEnv();
+
+}