diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml
index f1291c3..58c2c5a 100644
--- a/.github/workflows/c-cpp.yml
+++ b/.github/workflows/c-cpp.yml
@@ -16,9 +16,9 @@ jobs:
     - uses: actions/checkout@v2
     - name: make
       run: |
-          make -j
+          make -j4
           cd module
-          make all -j
+          make all -j4
           cd ..
           make test
           tar -czf nasal-mac-nightly.tgz .
@@ -42,9 +42,9 @@ jobs:
     - uses: actions/checkout@v2
     - name: make
       run: |
-          make -j
+          make -j4
           cd module
-          make all -j
+          make all -j4
           cd ..
           make test
           touch nasal-linux-x86_64-nightly.tgz
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 90dd40c..fdd7981 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,22 +9,12 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 set(CMAKE_CXX_FLAGS_RELEASE_INIT "-Wshadow -Wall")
 
+add_compile_options(-fPIC)
+
 # generate release executables
 set(CMAKE_BUILD_TYPE "Release")
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/module)
-
-add_library(fib SHARED ${CMAKE_SOURCE_DIR}/module/fib.cpp)
-target_include_directories(fib PRIVATE ${CMAKE_SOURCE_DIR}/src)
-
-add_library(key SHARED ${CMAKE_SOURCE_DIR}/module/keyboard.cpp)
-target_include_directories(key PRIVATE ${CMAKE_SOURCE_DIR}/src)
-
-add_library(mat SHARED ${CMAKE_SOURCE_DIR}/module/matrix.cpp)
-target_include_directories(mat PRIVATE ${CMAKE_SOURCE_DIR}/src)
-
-add_library(nasock SHARED ${CMAKE_SOURCE_DIR}/module/nasocket.cpp)
-target_include_directories(nasock PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
+# build nasal used object
 set(NASAL_OBJECT_SOURCE_FILE
     ${CMAKE_SOURCE_DIR}/src/ast_dumper.cpp
     ${CMAKE_SOURCE_DIR}/src/ast_visitor.cpp
@@ -42,18 +32,16 @@ set(NASAL_OBJECT_SOURCE_FILE
     ${CMAKE_SOURCE_DIR}/src/nasal_new_vm.cpp
     ${CMAKE_SOURCE_DIR}/src/optimizer.cpp
     ${CMAKE_SOURCE_DIR}/src/symbol_finder.cpp)
-
-add_executable(nasal ${CMAKE_SOURCE_DIR}/src/nasal_new_main.cpp)
-
 add_library(nasal-object STATIC ${NASAL_OBJECT_SOURCE_FILE})
 target_include_directories(nasal-object PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
+# build nasal
+add_executable(nasal ${CMAKE_SOURCE_DIR}/src/nasal_new_main.cpp)
 target_link_libraries(nasal nasal-object)
 if(NOT CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
     target_link_libraries(nasal dl)
 endif()
 target_include_directories(nasal PRIVATE ${CMAKE_SOURCE_DIR}/src)
-
 if(NOT CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
     add_custom_command(
         TARGET nasal POST_BUILD
@@ -61,4 +49,28 @@ if(NOT CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
                 ${CMAKE_SOURCE_DIR}/build/nasal
                 ${CMAKE_SOURCE_DIR}/nasal
     )
-endif()
\ No newline at end of file
+endif()
+
+# build module
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/module)
+
+set(MODULE_USED_OBJECT_SOURCE_FILE
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_misc.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_gc.cpp)
+add_library(module-used-object STATIC ${MODULE_USED_OBJECT_SOURCE_FILE})
+
+add_library(fib SHARED ${CMAKE_SOURCE_DIR}/module/fib.cpp)
+target_include_directories(fib PRIVATE ${CMAKE_SOURCE_DIR}/src)
+target_link_libraries(fib module-used-object)
+
+add_library(key SHARED ${CMAKE_SOURCE_DIR}/module/keyboard.cpp)
+target_include_directories(key PRIVATE ${CMAKE_SOURCE_DIR}/src)
+target_link_libraries(key module-used-object)
+
+add_library(mat SHARED ${CMAKE_SOURCE_DIR}/module/matrix.cpp)
+target_include_directories(mat PRIVATE ${CMAKE_SOURCE_DIR}/src)
+target_link_libraries(mat module-used-object)
+
+add_library(nasock SHARED ${CMAKE_SOURCE_DIR}/module/nasocket.cpp)
+target_include_directories(nasock PRIVATE ${CMAKE_SOURCE_DIR}/src)
+target_link_libraries(nasock module-used-object)
\ No newline at end of file
diff --git a/main.cpp b/main.cpp
deleted file mode 100644
index 084e28d..0000000
--- a/main.cpp
+++ /dev/null
@@ -1,178 +0,0 @@
-#include "nasal.h"
-#include "nasal_err.h"
-#include "nasal_lexer.h"
-#include "nasal_ast.h"
-#include "nasal_parse.h"
-#include "nasal_import.h"
-#include "nasal_opt.h"
-#include "nasal_gc.h"
-#include "nasal_builtin.h"
-#include "nasal_codegen.h"
-#include "nasal_vm.h"
-#include "nasal_dbg.h"
-
-#include <thread>
-#include <unordered_map>
-
-const u32 VM_AST   =0x01;
-const u32 VM_CODE  =0x02;
-const u32 VM_TIME  =0x04;
-const u32 VM_EXEC  =0x08;
-const u32 VM_DETAIL=0x10;
-const u32 VM_DEBUG =0x20;
-
-std::ostream& help(std::ostream& out) {
-    out
-    <<"     ,--#-,\n"
-    <<"<3  / \\____\\  <3\n"
-    <<"    |_|__A_|\n"
-#ifdef _WIN32
-    <<"use command <chcp 65001> to use unicode.\n"
-#endif
-    <<"\nnasal <option>\n"
-    <<"option:\n"
-    <<"   -h,   --help   | get help.\n"
-    <<"\nnasal [option] <file> [argv]\n"
-    <<"option:\n"
-    <<"   -a,   --ast    | view abstract syntax tree.\n"
-    <<"   -c,   --code   | view bytecode.\n"
-    <<"   -e,   --exec   | execute.\n"
-    <<"   -t,   --time   | show execute time.\n"
-    <<"   -d,   --detail | get detail info.\n"
-    <<"   -dbg, --debug  | debug mode.\n"
-    <<"file:\n"
-    <<"   <filename>     | execute file.\n"
-    <<"argv:\n"
-    <<"   <args>         | cmd arguments used in program.\n";
-    return out;
-}
-
-std::ostream& logo(std::ostream& out) {
-    out
-    <<"       __                _\n"
-    <<"    /\\ \\ \\__ _ ___  __ _| |\n"
-    <<"   /  \\/ / _` / __|/ _` | |\n"
-    <<"  / /\\  / (_| \\__ \\ (_| | |\n"
-    <<"  \\_\\ \\/ \\__,_|___/\\__,_|_|\n"
-    <<"ver  : "<<__nasver<<" ("<<__DATE__<<" "<<__TIME__<<")\n"
-    <<"std  : c++ "<<__cplusplus<<"\n"
-    <<"core : "<<std::thread::hardware_concurrency()<<" core(s)\n"
-    <<"repo : https://github.com/ValKmjolnir/Nasal-Interpreter\n"
-    <<"repo : https://gitee.com/valkmjolnir/Nasal-Interpreter\n"
-    <<"wiki : https://wiki.flightgear.org/Nasal_scripting_language\n"
-    <<"input <nasal -h> to get help .\n";
-    return out;
-}
-
-[[noreturn]]
-void err() {
-    std::cerr
-    <<"invalid argument(s).\n"
-    <<"use <nasal -h> to get help.\n";
-    std::exit(1);
-}
-
-void execute(
-    const string& file,
-    const std::vector<string>& argv,
-    const u32 cmd
-) {
-    using clk=std::chrono::high_resolution_clock;
-    const auto den=clk::duration::period::den;
-
-    error   err;
-    lexer   lex(err);
-    parse   parse(err);
-    linker  ld(err);
-    codegen gen(err);
-    vm      ctx;
-
-    // lexer scans file to get tokens
-    lex.scan(file).chkerr();
-
-    // parser gets lexer's token list to compile
-    parse.compile(lex).chkerr();
-    if (cmd&VM_AST) {
-        parse.tree().dump();
-    }
-
-    // linker gets parser's ast and load import files to this ast
-    ld.link(parse, file, cmd&VM_DETAIL).chkerr();
-
-    // optimizer does simple optimization on ast
-    optimize(parse.tree());
-
-    // code generator gets parser's ast and import file list to generate code
-    gen.compile(parse, ld).chkerr();
-    if (cmd&VM_CODE) {
-        gen.print();
-    }
-
-    // run
-    auto start=clk::now();
-    if (cmd&VM_DEBUG) {
-        dbg(err).run(gen, ld, argv);
-    } else if (cmd&VM_TIME || cmd&VM_EXEC) {
-        ctx.run(gen, ld, argv, cmd&VM_DETAIL);
-    }
-
-    // get running time
-    if (cmd&VM_TIME) {
-        f64 tm=(clk::now()-start).count()*1.0/den;
-        std::clog<<"process exited after "<<tm<<"s.\n\n";
-    }
-}
-
-i32 main(i32 argc, const char* argv[]) {
-    // output version info
-    if (argc<=1) {
-        std::clog<<logo;
-        return 0;
-    }
-
-    // run directly or show help
-    if (argc==2) {
-        string s(argv[1]);
-        if (s=="-h" || s=="--help") {
-            std::clog<<help;
-        } else if (s[0]!='-') {
-            execute(s, {}, VM_EXEC);
-        } else {
-            err();
-        }
-        return 0;
-    }
-
-    // execute with arguments
-    const std::unordered_map<string,u32> cmdlst={
-        {"--ast", VM_AST},
-        {"-a", VM_AST},
-        {"--code", VM_CODE},
-        {"-c", VM_CODE},
-        {"--exec", VM_EXEC},
-        {"-e", VM_EXEC},
-        {"--time", VM_TIME|VM_EXEC},
-        {"-t", VM_TIME|VM_EXEC},
-        {"--detail", VM_DETAIL|VM_EXEC},
-        {"-d", VM_DETAIL|VM_EXEC},
-        {"--debug", VM_DEBUG},
-        {"-dbg", VM_DEBUG}
-    };
-    u32 cmd=0;
-    string filename="";
-    std::vector<string> vm_argv;
-    for(i32 i=1; i<argc; ++i) {
-        if (cmdlst.count(argv[i])) {
-            cmd|=cmdlst.at(argv[i]);
-        } else if (!filename.length()) {
-            filename=argv[i];
-        } else {
-            vm_argv.push_back(argv[i]);
-        }
-    }
-    if (!filename.length()) {
-        err();
-    }
-    execute(filename, vm_argv, cmd?cmd:VM_EXEC);
-    return 0;
-}
\ No newline at end of file
diff --git a/makefile b/makefile
index e9fa4d5..6c04e62 100644
--- a/makefile
+++ b/makefile
@@ -1,5 +1,3 @@
-.PHONY:test clean
-
 STD=c++17
 
 NASAL_OBJECT=\
@@ -83,38 +81,12 @@ nasal_new_dbg.o: src/nasal_new_dbg.h src/nasal_new_dbg.cpp
 nasal_new_clean:
 	rm $(NASAL_OBJECT)
 
-SRC=\
-	main.cpp\
-	nasal_ast.h\
-	nasal_err.h\
-	nasal_builtin.h\
-	nasal_opcode.h\
-	nasal_opt.h\
-	nasal_codegen.h\
-	nasal_gc.h\
-	nasal_import.h\
-	nasal_lexer.h\
-	nasal_parse.h\
-	nasal_vm.h\
-	nasal_dbg.h\
-	nasal.h
-
-nasal_old:$(SRC)
-	$(CXX) -std=$(STD) -O3 main.cpp -o nasal_old -fno-exceptions -ldl -Wshadow -Wall
-
-nasal_old.exe:$(SRC)
-	$(CXX) -std=$(STD) -O3 main.cpp -o nasal_old.exe -fno-exceptions -Wshadow -Wall -static
-
-stable-release:$(SRC)
-	$(CXX) -std=$(STD) -O2 main.cpp -o nasal_old -fno-exceptions -ldl -Wshadow -Wall
-
-stable-release-mingw:$(SRC)
-	$(CXX) -std=$(STD) -O2 main.cpp -o nasal_old.exe -fno-exceptions -Wshadow -Wall -static
-
+.PHONY: clean
 clean:
 	@ echo "[clean] nasal" && if [ -e nasal ]; then rm nasal; fi
 	@ echo "[clean] nasal.exe" && if [ -e nasal.exe ]; then rm nasal.exe; fi
 
+.PHONY: test
 test:nasal
 	@ ./nasal -e test/ascii-art.nas
 	@ ./nasal -t -d test/bfs.nas
diff --git a/module/fib.cpp b/module/fib.cpp
index f0a546a..1ff1891 100644
--- a/module/fib.cpp
+++ b/module/fib.cpp
@@ -1,7 +1,7 @@
 // module for test
 
 #include <iostream>
-#include "../nasal.h"
+#include "../src/nasal_new_header.h"
 
 namespace nasal_fib_module {
 
diff --git a/module/keyboard.cpp b/module/keyboard.cpp
index c3c8e2f..da2f9c5 100644
--- a/module/keyboard.cpp
+++ b/module/keyboard.cpp
@@ -1,4 +1,4 @@
-#include "../nasal.h"
+#include "../src/nasal_new_header.h"
 #include <iostream>
 
 #ifndef _MSC_VER
diff --git a/module/makefile b/module/makefile
index d95626d..33c6b4e 100644
--- a/module/makefile
+++ b/module/makefile
@@ -1,9 +1,10 @@
 .PHONY=clean all winall
 
-dynamic_libs_so=libfib.so libkey.so libnasock.so libmat.so
-dynamic_libs_dll=libfib.dll libkey.dll libnasock.dll libmat.dll
+dynamic_libs_so = libfib.so libkey.so libnasock.so libmat.so
+dynamic_libs_dll = libfib.dll libkey.dll libnasock.dll libmat.dll
 
-used_header= ../src/nasal_new_header.h ../src/nasal_new_gc.h
+used_header = ../src/nasal_new_header.h ../src/nasal_new_gc.h
+used_object = ../nasal_new_misc.o ../nasal_new_gc.o
 
 STD=c++17
 
@@ -12,48 +13,48 @@ all: $(dynamic_libs_so)
 winall: $(dynamic_libs_dll)
 	@ echo [Compiling] done
 
-libfib.so: fib.cpp $(used_header)
+libfib.so: fib.cpp $(used_header) $(used_object)
 	@ echo "[Compiling] libfib.so"
 	@ $(CXX) -std=$(STD) -c -O3 fib.cpp -fPIC -o fib.o
-	@ $(CXX) -shared -o libfib.so fib.o
+	@ $(CXX) -shared -o libfib.so fib.o $(used_object)
 	@ rm fib.o
-libfib.dll: fib.cpp $(used_header)
+libfib.dll: fib.cpp $(used_header) $(used_object)
 	@ echo [Compiling] libfib.dll
 	@ $(CXX) -std=$(STD) -c -O3 fib.cpp -fPIC -o fib.o
-	@ $(CXX) -shared -o libfib.dll fib.o
+	@ $(CXX) -shared -o libfib.dll fib.o $(used_object) -static
 	@ del fib.o
 
-libkey.so: keyboard.cpp $(used_header)
+libkey.so: keyboard.cpp $(used_header) $(used_object)
 	@ echo "[Compiling] libkey.so"
 	@ $(CXX) -std=$(STD) -c -O3 keyboard.cpp -fPIC -o keyboard.o
-	@ $(CXX) -shared -o libkey.so keyboard.o
+	@ $(CXX) -shared -o libkey.so keyboard.o $(used_object)
 	@ rm keyboard.o
-libkey.dll: keyboard.cpp $(used_header)
+libkey.dll: keyboard.cpp $(used_header) $(used_object)
 	@ echo [Compiling] libkey.dll
 	@ $(CXX) -std=$(STD) -c -O3 keyboard.cpp -fPIC -o keyboard.o -static
-	@ $(CXX) -shared -o libkey.dll keyboard.o -static
+	@ $(CXX) -shared -o libkey.dll keyboard.o $(used_object) -static
 	@ del keyboard.o
 
-libnasock.so: nasocket.cpp $(used_header)
+libnasock.so: nasocket.cpp $(used_header) $(used_object)
 	@ echo "[Compiling] libnasock.so"
 	@ $(CXX) -std=$(STD) -c -O3 nasocket.cpp -fPIC -o nasocket.o
-	@ $(CXX) -shared -o libnasock.so nasocket.o
+	@ $(CXX) -shared -o libnasock.so nasocket.o $(used_object)
 	@ rm nasocket.o
-libnasock.dll: nasocket.cpp $(used_header)
+libnasock.dll: nasocket.cpp $(used_header) $(used_object)
 	@ echo [Compiling] libnasock.dll
 	@ $(CXX) -std=$(STD) -c -O3 nasocket.cpp -fPIC -o nasocket.o -lwsock32 -static
-	@ $(CXX) -shared -o libnasock.dll nasocket.o -lwsock32 -static
+	@ $(CXX) -shared -o libnasock.dll nasocket.o $(used_object) -lwsock32 -static
 	@ del nasocket.o
 
-libmat.so: matrix.cpp $(used_header)
+libmat.so: matrix.cpp $(used_header) $(used_object)
 	@ echo "[Compiling] libmat.so"
 	@ $(CXX) -std=$(STD) -c -O3 matrix.cpp -fPIC -o matrix.o
-	@ $(CXX) -shared -o libmat.so matrix.o
+	@ $(CXX) -shared -o libmat.so matrix.o $(used_object)
 	@ rm matrix.o
-libmat.dll: matrix.cpp $(used_header)
+libmat.dll: matrix.cpp $(used_header) $(used_object)
 	@ echo [Compiling] libmat.dll
 	@ $(CXX) -std=$(STD) -c -O3 matrix.cpp -fPIC -o matrix.o -static
-	@ $(CXX) -shared -o libmat.dll matrix.o -static
+	@ $(CXX) -shared -o libmat.dll matrix.o $(used_object) -static
 	@ del matrix.o
 
 clean:
diff --git a/module/matrix.cpp b/module/matrix.cpp
index 5bf8939..da3cbdc 100644
--- a/module/matrix.cpp
+++ b/module/matrix.cpp
@@ -1,4 +1,4 @@
-#include "../nasal.h"
+#include "../src/nasal_new_header.h"
 #include <cmath>
 
 var nas_vec2(var* args, usize size, gc* ngc) {
diff --git a/module/nasocket.cpp b/module/nasocket.cpp
index 5320244..902fe9a 100644
--- a/module/nasocket.cpp
+++ b/module/nasocket.cpp
@@ -1,4 +1,4 @@
-#include "../nasal.h"
+#include "../src/nasal_new_header.h"
 
 #ifndef _MSC_VER
 #include <unistd.h>
diff --git a/nasal.h b/nasal.h
deleted file mode 100644
index 7290f62..0000000
--- a/nasal.h
+++ /dev/null
@@ -1,255 +0,0 @@
-#pragma once
-
-#ifndef __nasver
-#define __nasver "10.1"
-#endif
-
-#include <cstdint>
-#include <iostream>
-#include <fstream>
-#include <cstring>
-#include <cmath>
-#include <vector>
-
-bool is_windows() {
-#if defined(_WIN32) || defined(_WIN64)
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_linux() {
-#if defined __linux__
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_macos() {
-#if defined __APPLE__
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_x86() {
-#if defined(__i386__) || defined(_M_IX86)
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_amd64() {
-#if defined(__amd64__) || defined(_M_X64)
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_x86_64() {
-    return is_amd64();
-}
-
-bool is_arm() {
-#if defined(__arm__) || defined(_M_ARM)
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_aarch64() {
-#if defined(__aarch64__) || defined(_M_ARM64)
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_ia64() {
-#if defined(__ia64__)
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_powerpc() {
-#if defined(__powerpc__)
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_superh() {
-#if defined(__sh__)
-    return true;
-#else
-    return false;
-#endif
-}
-
-using i32=std::int32_t;
-using i64=std::int64_t;
-using u8=std::uint8_t;
-using u16=std::uint16_t;
-using u32=std::uint32_t;
-using u64=std::uint64_t;
-using usize=std::size_t;
-using f64=double;
-using std::string;
-
-const u32 STACK_DEPTH=4096;
-
-f64 hex2f(const char* str) {
-    f64 ret=0;
-    for(; *str; ++str) {
-        if ('0'<=*str && *str<='9') {
-            ret=ret*16+(*str-'0');
-        } else if ('a'<=*str && *str<='f') {
-            ret=ret*16+(*str-'a'+10);
-        } else if ('A'<=*str && *str<='F') {
-            ret=ret*16+(*str-'A'+10);
-        } else {
-            return nan("");
-        }
-    }
-    return ret;
-}
-
-f64 oct2f(const char* str) {
-    f64 ret=0;
-    while('0'<=*str && *str<'8') {
-        ret=ret*8+(*str++-'0');
-    }
-    if (*str) {
-        return nan("");
-    }
-    return ret;
-}
-
-// we have the same reason not using atof here
-// just as andy's interpreter does.
-// it is not platform independent, and may have strange output.
-// so we write a new function here to convert str to number manually.
-// but this also makes 0.1+0.2==0.3,
-// not another result that you may get in other languages.
-f64 dec2f(const char* str) {
-    f64 ret=0,negative=1,num_pow=0;
-    while('0'<=*str && *str<='9') {
-        ret=ret*10+(*str++-'0');
-    }
-    if (!*str) {
-        return ret;
-    }
-    if (*str=='.') {
-        if (!*++str) {
-            return nan("");
-        }
-        num_pow=0.1;
-        while('0'<=*str && *str<='9') {
-            ret+=num_pow*(*str++-'0');
-            num_pow*=0.1;
-        }
-        if (!*str) {
-            return ret;
-        }
-    }
-    if (*str!='e' && *str!='E') {
-        return nan("");
-    }
-    if (!*++str) {
-        return nan("");
-    }
-    if (*str=='-' || *str=='+') {
-        negative=(*str++=='-'? -1:1);
-    }
-    if (!*str) {
-        return nan("");
-    }
-    num_pow=0;
-    while('0'<=*str && *str<='9') {
-        num_pow=num_pow*10+(*str++-'0');
-    }
-    if (*str) {
-        return nan("");
-    }
-    return ret*std::pow(10,negative*num_pow);
-}
-
-f64 str2num(const char* str) {
-    bool negative=false;
-    f64 res=0;
-    if (*str=='-' || *str=='+') {
-        negative=(*str++=='-');
-    }
-    if (!*str) {
-        return nan("");
-    }
-    if (str[0]=='0' && str[1]=='x') {
-        res=hex2f(str+2);
-    } else if (str[0]=='0' && str[1]=='o') {
-        res=oct2f(str+2);
-    } else {
-        res=dec2f(str);
-    }
-    return negative?-res:res;
-}
-
-i32 utf8_hdchk(const char head) {
-    // RFC-2279 but now we use RFC-3629 so nbytes is less than 4
-    const u8 c=(u8)head;
-    if ((c>>5)==0x06) { // 110x xxxx (10xx xxxx)^1
-        return 1;
-    }
-    if ((c>>4)==0x0e) { // 1110 xxxx (10xx xxxx)^2
-        return 2;
-    }
-    if ((c>>3)==0x1e) { // 1111 0xxx (10xx xxxx)^3
-        return 3;
-    }
-    return 0;
-}
-
-string chrhex(const char c) {
-    const char hextbl[]="0123456789abcdef";
-    return {hextbl[(c&0xf0)>>4],hextbl[c&0x0f]};
-}
-
-string rawstr(const string& str, const usize maxlen=0) {
-    string ret("");
-    for(auto i:str) {
-        // windows doesn't output unicode normally, so we output the hex
-        if (is_windows() && i<=0) {
-            ret+="\\x"+chrhex(i);
-            continue;
-        }
-        switch(i) {
-            case '\0':  ret+="\\0"; break;
-            case '\a':  ret+="\\a"; break;
-            case '\b':  ret+="\\b"; break;
-            case '\t':  ret+="\\t"; break;
-            case '\n':  ret+="\\n"; break;
-            case '\v':  ret+="\\v"; break;
-            case '\f':  ret+="\\f"; break;
-            case '\r':  ret+="\\r"; break;
-            case '\033':ret+="\\e"; break;
-            case '\"':  ret+="\\\"";break;
-            case '\'':  ret+="\\\'";break;
-            case '\\':  ret+="\\\\";break;
-            default:    ret+=i;     break;
-        }
-    }
-    if (maxlen && ret.length()>maxlen) {
-        ret=ret.substr(0,maxlen)+"...";
-    }
-    return ret;
-}
-
-#include "nasal_gc.h" // declarations of var and nasal_gc
diff --git a/nasal_ast.h b/nasal_ast.h
deleted file mode 100644
index c424854..0000000
--- a/nasal_ast.h
+++ /dev/null
@@ -1,301 +0,0 @@
-#pragma once
-
-#include <vector>
-#include <cstring>
-
-#include "nasal.h"
-#include "nasal_err.h"
-
-enum ast_node:u32 {
-    ast_null=0,      // null node
-    ast_root,        // mark the root node of ast
-    ast_block,       // expression block 
-    ast_file,        // used to store which file the sub-tree is on, only used in main block
-    ast_nil,         // nil keyword
-    ast_num,         // number, basic value type
-    ast_str,         // string, basic value type
-    ast_id,          // identifier
-    ast_bool,        // bools
-    ast_func,        // func keyword
-    ast_hash,        // hash, basic value type
-    ast_vec,         // vector, basic value type
-    ast_pair,        // pair of key and value in hashmap
-    ast_call,        // mark a sub-tree of calling an identifier
-    ast_callh,       // id.name
-    ast_callv,       // id[index]
-    ast_callf,       // id()
-    ast_subvec,      // id[index:index]
-    ast_params,      // mark a sub-tree of function parameters
-    ast_default,     // default parameter
-    ast_dynamic,     // dynamic parameter
-    ast_and,         // and keyword
-    ast_or,          // or keyword
-    ast_equal,       // =
-    ast_addeq,       // +=
-    ast_subeq,       // -=
-    ast_multeq,      // *=
-    ast_diveq,       // /=
-    ast_lnkeq,       // ~=
-    ast_btandeq,     // &=
-    ast_btoreq,      // |=
-    ast_btxoreq,     // ^=
-    ast_cmpeq,       // ==
-    ast_neq,         // !=
-    ast_less,        // <
-    ast_leq,         // <=
-    ast_grt,         // >
-    ast_geq,         // >=
-    ast_add,         // +
-    ast_sub,         // -
-    ast_mult,        // *
-    ast_div,         // /
-    ast_link,        // ~
-    ast_neg,         // unary -
-    ast_lnot,        // unary !
-    ast_bnot,        // unary ~ bitwise not
-    ast_bitor,       // bitwise or
-    ast_bitxor,      // bitwise xor
-    ast_bitand,      // bitwise and
-    ast_trino,       // ?:
-    ast_for,         // for keyword
-    ast_forindex,    // forindex keyword
-    ast_foreach,     // foreach keyword
-    ast_while,       // while
-    ast_iter,        // iterator, used in forindex/foreach
-    ast_cond,        // mark a sub-tree of conditional expression
-    ast_if,          // if keyword
-    ast_elsif,       // elsif keyword
-    ast_else,        // else keyword
-    ast_multi_id,    // multi identifiers sub-tree
-    ast_tuple,       // tuple, only used in multiple assignment
-    ast_def,         // definition
-    ast_multi_assign,// multi assignment sub-tree
-    ast_continue,    // continue keyword, only used in loop
-    ast_break,       // break keyword, only used in loop
-    ast_ret          // return keyword, only used in function block
-};
-
-const char* ast_name[]={
-    "Null",
-    "AbstractSyntaxTreeRoot",
-    "CodeBlock",
-    "FileIndex",
-    "NilLiteral",
-    "NumberLiteral",
-    "StringLiteral",
-    "Identifier",
-    "BoolLiteral",
-    "Function",
-    "HashMap",
-    "Vector",
-    "HashMapPair",
-    "IdentifierCall",
-    "HashMapCall",
-    "VectorCall",
-    "FunctionCall",
-    "SubVector",
-    "ParameterList",
-    "DefaultParameter",
-    "DynamicParameter",
-    "And",
-    "Or",
-    "Equal",
-    "AddEqual",
-    "SubEqual",
-    "MultEqual",
-    "DivEqual",
-    "LinkEqual",
-    "BitwiseAndEqual",
-    "BitwiseOrEqual",
-    "BitwiseXorEqual",
-    "CompareEqual",
-    "NotEqual",
-    "Less",
-    "LessOrEqual",
-    "Great",
-    "GreatOrEqual",
-    "Add",
-    "Sub",
-    "Mult",
-    "Div",     
-    "Link",
-    "Negative",
-    "LogicalNot",
-    "BitwiseNot",
-    "BitwiseOr",
-    "BitwiseXor",
-    "BitwiseAnd",
-    "Trinocular",
-    "ForLoop",
-    "ForindexLoop",
-    "ForeachLoop",
-    "WhileLoop",
-    "Iterator",
-    "Condition",
-    "If",
-    "Elsif",
-    "Else",
-    "LeftTuple",
-    "Tuple",
-    "Definition",
-    "MultipleAssignment",
-    "Continue",
-    "Break",
-    "Return"
-};
-
-class ast {
-public:
-    ast(const ast&) = delete;
-    ast& operator=(const ast&) = delete;
-
-    ast(ast&&) = default;
-    ast& operator=(ast&&) = default;
-
-private:
-    void print(u32, bool, std::vector<string>&) const;
-
-private:
-    span loc;
-    u32 nd_type;
-    f64 nd_num;
-    string nd_str;
-    std::vector<ast> nd_child;
-
-public:
-    ast(const span& s, const u32 t)
-        : loc(s), nd_type(t), nd_num(0), nd_str("") {}
-
-public:
-    void dump() const;
-    void clear();
-
-public:
-    ast& operator[](usize n) {return nd_child[n];}
-    const ast& operator[](usize n) const {return nd_child[n];}
-    usize size() const {return nd_child.size();}
-
-public:
-    void add(ast&& node) {nd_child.push_back(std::move(node));}
-    void set_begin(const u32, const u32);
-    void set_end(const u32, const u32);
-    void set_type(const u32 t) {nd_type=t;}
-    void set_str(const string& s) {nd_str=s;}
-    void set_num(const f64 n) {nd_num=n;}
-
-public:
-    u32 line() const {return loc.end_line;}
-    u32 type() const {return nd_type;}
-    f64 num()  const {return nd_num;}
-    const string& str() const {return nd_str;}
-    const string& file() const {return loc.file;}
-    const span& location() const {return loc;}
-
-    const std::vector<ast>& child() const {return nd_child;}
-    std::vector<ast>& child() {return nd_child;}
-
-    void update_span();
-    void update_span(const span&);
-};
-
-void ast::set_begin(const u32 l, const u32 c) {
-    loc.begin_line=l;
-    loc.begin_column=c;
-}
-
-void ast::set_end(const u32 l, const u32 c) {
-    loc.end_line=l;
-    loc.end_column=c;
-}
-
-void ast::clear() {
-    loc={0, 0, 0, 0, ""};
-    nd_num=0;
-    nd_str.clear();
-    nd_type=ast_null;
-    nd_child.clear();
-}
-
-void ast::dump() const{
-    std::vector<string> tmp;
-    print(0, false, tmp);
-}
-
-void ast::print(u32 depth, bool last, std::vector<string>& indent) const{
-    // output the indentation first
-    for(auto& i:indent) {
-        std::cout<<i;
-    }
-
-    // output ast node name
-    std::cout<<ast_name[nd_type];
-
-    // output string literal and number
-    if (nd_type==ast_str ||
-        nd_type==ast_id ||
-        nd_type==ast_bool ||
-        nd_type==ast_default ||
-        nd_type==ast_dynamic ||
-        nd_type==ast_callh) {
-        std::cout<<":"<<rawstr(nd_str);
-    } else if (nd_type==ast_num || nd_type==ast_file) {
-        std::cout<<":"<<nd_num;
-    }
-
-    // okay, we must know that begin_column starts from index 0
-    std::cout<<" --> "<<loc.file<<":"<<loc.begin_line<<":"<<loc.begin_column+1<<"\n";
-
-    // output tree structure
-    if (last && depth) {
-        indent.back()="  ";
-    } else if (!last && depth) {
-        indent.back()=is_windows()? "| ":"│ ";
-    }
-    for(u32 i=0; i<nd_child.size(); ++i) {
-        if (is_windows()) {
-            indent.push_back(i==nd_child.size()-1?"+-":"|-");
-        } else {
-            indent.push_back(i==nd_child.size()-1?"└─":"├─");
-        }
-        nd_child[i].print(depth+1,i==nd_child.size()-1,indent);
-        indent.pop_back();
-    }
-}
-
-void ast::update_span() {
-    if (!nd_child.size()) {
-        return;
-    }
-    for(const auto& i:nd_child) {
-        if (loc.begin_line>i.loc.begin_line) {
-            loc.begin_line=i.loc.begin_line;
-            loc.begin_column=i.loc.begin_column;
-        } else if (loc.begin_line==i.loc.begin_line && loc.begin_column>i.loc.begin_column) {
-            loc.begin_column=i.loc.begin_column;
-        }
-        if (loc.end_line<i.loc.end_line) {
-            loc.end_line=i.loc.end_line;
-            loc.end_column=i.loc.end_column;
-        } else if (loc.end_line==i.loc.end_line && loc.end_column<i.loc.end_column) {
-            loc.end_column=i.loc.end_column;
-        }
-        loc.file=i.loc.file;
-    }
-}
-
-void ast::update_span(const span& tloc) {
-    update_span();
-    if (loc.begin_line>tloc.begin_line) {
-        loc.begin_line=tloc.begin_line;
-        loc.begin_column=tloc.begin_column;
-    } else if (loc.begin_line==tloc.begin_line && loc.begin_column>tloc.begin_column) {
-        loc.begin_column=tloc.begin_column;
-    }
-    if (loc.end_line<tloc.end_line) {
-        loc.end_line=tloc.end_line;
-        loc.end_column=tloc.end_column;
-    } else if (loc.end_line==tloc.end_line && loc.end_column<tloc.end_column) {
-        loc.end_column=tloc.end_column;
-    }
-    loc.file=tloc.file;
-}
\ No newline at end of file
diff --git a/nasal_builtin.h b/nasal_builtin.h
deleted file mode 100644
index d800bd3..0000000
--- a/nasal_builtin.h
+++ /dev/null
@@ -1,1400 +0,0 @@
-#pragma once
-
-#include "nasal.h"
-#include "nasal_gc.h"
-
-#ifndef _MSC_VER
-#include <unistd.h>
-#include <dirent.h>
-#else
-#pragma warning (disable:4566) // i know i'm using utf-8, fuck you
-#pragma warning (disable:4244)
-#pragma warning (disable:4267)
-#pragma warning (disable:4996)
-#define _CRT_SECURE_NO_DEPRECATE 1
-#define _CRT_NONSTDC_NO_DEPRECATE 1
-#include <io.h>
-#include <direct.h>
-#endif
-
-#include <sstream>
-#include <cmath>
-#include <thread>
-#include <sys/stat.h>
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <dlfcn.h>
-#include <sys/wait.h>
-#endif
-
-#if defined __APPLE__
-#include <crt_externs.h>
-#define environ (*_NSGetEnviron())
-#endif
-
-var builtin_print(var* local, gc& ngc) {
-    for(auto& i:local[1].vec().elems) {
-        std::cout<<i;
-    }
-    std::cout<<std::flush;
-    return nil;
-}
-
-var builtin_println(var* local, gc& ngc) {
-    for(auto& i:local[1].vec().elems) {
-        std::cout<<i;
-    }
-    std::cout<<std::endl;
-    return nil;
-}
-
-var builtin_exit(var* local, gc& ngc) {
-    std::exit(local[1].num());
-    return nil;
-}
-
-var builtin_abort(var* local, gc& ngc) {
-    std::abort();
-    return nil;
-}
-
-var builtin_append(var* local, gc& ngc) {
-    var vec=local[1];
-    var elem=local[2];
-    if (vec.type!=vm_vec) {
-        return nas_err("append", "\"vec\" must be vector");
-    }
-    auto& v=vec.vec().elems;
-    for(auto& i:elem.vec().elems) {
-        v.push_back(i);
-    }
-    return nil;
-}
-
-var builtin_setsize(var* local, gc& ngc) {
-    var vec=local[1];
-    var size=local[2];
-    if (vec.type!=vm_vec) {
-        return nas_err("setsize", "\"vec\" must be vector");
-    }
-    if (size.type!=vm_num || size.num()<0) {
-        return nil;
-    }
-    vec.vec().elems.resize((i64)size.num(), nil);
-    return nil;
-}
-
-var builtin_system(var* local, gc& ngc) {
-    var str=local[1];
-    if (str.type!=vm_str) {
-        return var::num(-1);
-    }
-    return var::num((f64)system(str.str().c_str()));
-}
-
-var builtin_input(var* local, gc& ngc) {
-    var end=local[1];
-    var ret=ngc.alloc(vm_str);
-    if (end.type!=vm_str || end.str().length()>1 || !end.str().length()) {
-        std::cin>>ret.str();
-    } else {
-        std::getline(std::cin, ret.str(), end.str()[0]);
-    }
-    return ret;
-}
-
-var builtin_readfile(var* local, gc& ngc) {
-    var val=local[1];
-    if (val.type!=vm_str) {
-        return nas_err("io::readfile", "\"filename\" must be string");
-    }
-    std::ifstream in(val.str(), std::ios::binary);
-    std::stringstream rd;
-    if (!in.fail()) {
-        rd<<in.rdbuf();
-    }
-    return ngc.newstr(rd.str());
-}
-
-var builtin_fout(var* local, gc& ngc) {
-    var val=local[1];
-    var str=local[2];
-    if (val.type!=vm_str) {
-        return nas_err("io::fout", "\"filename\" must be string");
-    }
-    std::ofstream out(val.str());
-    if (out.fail()) {
-        return nas_err("io::fout", "cannot open <"+val.str()+">");
-    }
-    out<<str;
-    return nil;
-}
-
-var builtin_split(var* local, gc& ngc) {
-    var delimeter=local[1];
-    var str=local[2];
-    if (delimeter.type!=vm_str) {
-        return nas_err("split", "\"separator\" must be string");
-    }
-    if (str.type!=vm_str) {
-        return nas_err("split", "\"str\" must be string");
-    }
-    const string& deli=delimeter.str();
-    const string& s=str.str();
-
-    // avoid being sweeped
-    var res=ngc.temp=ngc.alloc(vm_vec);
-    auto& vec=res.vec().elems;
-
-    if (!deli.length()) {
-        for(auto i:s) {
-            vec.push_back(ngc.newstr(i));
-        }
-        ngc.temp=nil;
-        return res;
-    }
-    usize last=0;
-    usize pos=s.find(deli, 0);
-    while(pos!=string::npos) {
-        if (pos>last) {
-            vec.push_back(ngc.newstr(s.substr(last, pos-last)));
-        }
-        last=pos+deli.length();
-        pos=s.find(deli, last);
-    }
-    if (last!=s.length()) {
-        vec.push_back(ngc.newstr(s.substr(last)));
-    }
-    ngc.temp=nil;
-    return res;
-}
-
-var builtin_rand(var* local, gc& ngc) {
-    var val=local[1];
-    if (val.type!=vm_num && val.type!=vm_nil) {
-        return nas_err("rand", "\"seed\" must be nil or number");
-    }
-    if (val.type==vm_num) {
-        srand((u32)val.num());
-        return nil;
-    }
-    f64 num=0;
-    for(u32 i=0;i<5;++i) {
-        num=(num+rand())*(1.0/(RAND_MAX+1.0));
-    }
-    return var::num(num);
-}
-
-var builtin_id(var* local, gc& ngc) {
-    var val=local[1];
-    std::stringstream ss;
-    ss<<"0";
-    if (val.type>vm_num) {
-        ss<<"x"<<std::hex<<(u64)val.val.gcobj<<std::dec;
-    }
-    return ngc.newstr(ss.str());
-}
-
-var builtin_int(var* local, gc& ngc) {
-    var val=local[1];
-    if (val.type!=vm_num && val.type!=vm_str) {
-        return nil;
-    }
-    return var::num(f64((i32)val.tonum()));
-}
-
-var builtin_floor(var* local, gc& ngc) {
-    var val=local[1];
-    return var::num(std::floor(val.num()));
-}
-
-var builtin_num(var* local, gc& ngc) {
-    var val=local[1];
-    if (val.type==vm_num) {
-        return val;
-    }
-    if (val.type!=vm_str) {
-        return nil;
-    }
-    f64 res=val.tonum();
-    if (std::isnan(res)) {
-        return nil;
-    }
-    return var::num(res);
-}
-
-var builtin_pop(var* local, gc& ngc) {
-    var val=local[1];
-    if (val.type!=vm_vec) {
-        return nas_err("pop", "\"vec\" must be vector");
-    }
-    auto& vec=val.vec().elems;
-    if (vec.size()) {
-        var tmp=vec.back();
-        vec.pop_back();
-        return tmp;
-    }
-    return nil;
-}
-
-var builtin_str(var* local, gc& ngc) {
-    return ngc.newstr(local[1].tostr());
-}
-
-var builtin_size(var* local, gc& ngc) {
-    var val=local[1];
-    f64 num=0;
-    switch(val.type) {
-        case vm_num:  num=val.num();         break;
-        case vm_str:  num=val.str().length();break;
-        case vm_vec:  num=val.vec().size();  break;
-        case vm_hash: num=val.hash().size(); break;
-    }
-    return var::num(num);
-}
-
-var builtin_u32xor(var* local, gc& ngc) {
-    return var::num((f64)(u32(local[1].num())^u32(local[2].num())));
-}
-
-var builtin_u32and(var* local, gc& ngc) {
-    return var::num((f64)(u32(local[1].num())&u32(local[2].num())));
-}
-
-var builtin_u32or(var* local, gc& ngc) {
-    return var::num((f64)(u32(local[1].num())|u32(local[2].num())));
-}
-
-var builtin_u32nand(var* local, gc& ngc) {
-    return var::num((f64)(u32)(~(u32(local[1].num())&u32(local[2].num()))));
-}
-
-var builtin_u32not(var* local, gc& ngc) {
-    return var::num((f64)(u32)(~u32(local[1].num())));
-}
-
-var builtin_pow(var* local, gc& ngc) {
-    var x=local[1];
-    var y=local[2];
-    if (x.type!=vm_num || y.type!=vm_num) {
-        return var::num(std::nan(""));
-    }
-    return var::num(std::pow(x.num(), y.num()));
-}
-
-var builtin_sin(var* local, gc& ngc) {
-    var val=local[1];
-    return var::num(val.type==vm_num?sin(val.num()):std::nan(""));
-}
-
-var builtin_cos(var* local, gc& ngc) {
-    var val=local[1];
-    return var::num(val.type==vm_num?cos(val.num()):std::nan(""));
-}
-
-var builtin_tan(var* local, gc& ngc) {
-    var val=local[1];
-    return var::num(val.type==vm_num?tan(val.num()):std::nan(""));
-}
-
-var builtin_exp(var* local, gc& ngc) {
-    var val=local[1];
-    return var::num(val.type==vm_num?exp(val.num()):std::nan(""));
-}
-
-var builtin_lg(var* local, gc& ngc) {
-    var val=local[1];
-    return var::num(val.type==vm_num?log(val.num())/log(10.0):std::nan(""));
-}
-
-var builtin_ln(var* local, gc& ngc) {
-    var val=local[1];
-    return var::num(val.type==vm_num?log(val.num()):std::nan(""));
-}
-
-var builtin_sqrt(var* local, gc& ngc) {
-    var val=local[1];
-    return var::num(val.type==vm_num?sqrt(val.num()):std::nan(""));
-}
-
-var builtin_atan2(var* local, gc& ngc) {
-    var x=local[1];
-    var y=local[2];
-    if (x.type!=vm_num || y.type!=vm_num) {
-        return var::num(std::nan(""));
-    }
-    return var::num(atan2(y.num(), x.num()));
-}
-
-var builtin_isnan(var* local, gc& ngc) {
-    var x=local[1];
-    return (x.type==vm_num && std::isnan(x.num()))?one:zero;
-}
-
-var builtin_time(var* local, gc& ngc) {
-    var val=local[1];
-    if (val.type!=vm_num) {
-        return nas_err("time", "\"begin\" must be number");
-    }
-    time_t begin=(time_t)val.num();
-    return var::num((f64)time(&begin));
-}
-
-var builtin_contains(var* local, gc& ngc) {
-    var hash=local[1];
-    var key=local[2];
-    if (hash.type!=vm_hash || key.type!=vm_str) {
-        return zero;
-    }
-    return hash.hash().elems.count(key.str())?one:zero;
-}
-
-var builtin_delete(var* local, gc& ngc) {
-    var hash=local[1];
-    var key=local[2];
-    if (hash.type!=vm_hash) {
-        return nas_err("delete", "\"hash\" must be hash");
-    }
-    if (key.type!=vm_str) {
-        return nil;
-    }
-    if (hash.hash().elems.count(key.str())) {
-        hash.hash().elems.erase(key.str());
-    }
-    return nil;
-}
-
-var builtin_keys(var* local, gc& ngc) {
-    var hash=local[1];
-    if (hash.type!=vm_hash) {
-        return nas_err("keys", "\"hash\" must be hash");
-    }
-    // avoid being sweeped
-    var res=ngc.temp=ngc.alloc(vm_vec);
-    auto& vec=res.vec().elems;
-    for(auto& iter:hash.hash().elems) {
-        vec.push_back(ngc.newstr(iter.first));
-    }
-    ngc.temp=nil;
-    return res;
-}
-
-var builtin_die(var* local, gc& ngc) {
-    return nas_err("error", local[1].tostr());
-}
-
-var builtin_find(var* local, gc& ngc) {
-    var needle=local[1];
-    var haystack=local[2];
-    usize pos=haystack.tostr().find(needle.tostr());
-    if (pos==string::npos) {
-        return var::num((f64)-1);
-    }
-    return var::num((f64)pos);
-}
-
-var builtin_type(var* local, gc& ngc) {
-    switch(local[1].type) {
-        case vm_none: return ngc.newstr("undefined");break;
-        case vm_nil:  return ngc.newstr("nil");      break;
-        case vm_num:  return ngc.newstr("num");      break;
-        case vm_str:  return ngc.newstr("str");      break;
-        case vm_vec:  return ngc.newstr("vec");      break;
-        case vm_hash: return ngc.newstr("hash");     break;
-        case vm_func: return ngc.newstr("func");     break;
-        case vm_obj:  return ngc.newstr("obj");      break;
-        case vm_co:   return ngc.newstr("coroutine");break;
-    }
-    return nil;
-}
-
-var builtin_substr(var* local, gc& ngc) {
-    var str=local[1];
-    var beg=local[2];
-    var len=local[3];
-    if (str.type!=vm_str) {
-        return nas_err("substr", "\"str\" must be string");
-    }
-    if (beg.type!=vm_num || beg.num()<0) {
-        return nas_err("substr", "\"begin\" should be number >= 0");
-    }
-    if (len.type!=vm_num || len.num()<0) {
-        return nas_err("substr", "\"length\" should be number >= 0");
-    }
-    usize begin=(usize)beg.num();
-    usize length=(usize)len.num();
-    if (begin>=str.str().length()) {
-        return nas_err("susbtr", "begin index out of range: "+std::to_string(begin));
-    }
-    return ngc.newstr(str.str().substr(begin,length));
-}
-
-var builtin_streq(var* local, gc& ngc) {
-    var a=local[1];
-    var b=local[2];
-    return var::num(f64((a.type!=vm_str || b.type!=vm_str)?0:(a.str()==b.str())));
-}
-
-var builtin_left(var* local, gc& ngc) {
-    var str=local[1];
-    var len=local[2];
-    if (str.type!=vm_str) {
-        return nas_err("left", "\"string\" must be string");
-    }
-    if (len.type!=vm_num) {
-        return nas_err("left", "\"length\" must be number");
-    }
-    if (len.num()<0) {
-        return ngc.newstr("");
-    }
-    return ngc.newstr(str.str().substr(0,len.num()));
-}
-
-var builtin_right(var* local, gc& ngc) {
-    var str=local[1];
-    var len=local[2];
-    if (str.type!=vm_str) {
-        return nas_err("right", "\"string\" must be string");
-    }
-    if (len.type!=vm_num) {
-        return nas_err("right", "\"length\" must be number");
-    }
-    i32 length=(i32)len.num();
-    i32 srclen=str.str().length();
-    if (length>srclen) {
-        length=srclen;
-    }
-    if (length<0) {
-        length=0;
-    }
-    return ngc.newstr(str.str().substr(srclen-length, srclen));
-}
-
-var builtin_cmp(var* local, gc& ngc) {
-    var a=local[1];
-    var b=local[2];
-    if (a.type!=vm_str || b.type!=vm_str) {
-        return nas_err("cmp", "\"a\" and \"b\" must be string");
-    }
-    return var::num((f64)strcmp(a.str().c_str(), b.str().c_str()));
-}
-
-var builtin_chr(var* local, gc& ngc) {
-    const char* extend[]={
-        "€"," ","‚","ƒ","„","…","†","‡",
-        "ˆ","‰","Š","‹","Œ"," ","Ž"," ",
-        " ","‘","’","“","”","•","–","—",
-        "˜","™","š","›","œ"," ","ž","Ÿ",
-        " ","¡","¢","£","¤","¥","¦","§",
-        "¨","©","ª","«","¬"," ","®","¯",
-        "°","±","²","³","´","µ","¶","·",
-        "¸","¹","º","»","¼","½","¾","¿",
-        "À","Á","Â","Ã","Ä","Å","Æ","Ç",
-        "È","É","Ê","Ë","Ì","Í","Î","Ï",
-        "Ð","Ñ","Ò","Ó","Ô","Õ","Ö","×",
-        "Ø","Ù","Ú","Û","Ü","Ý","Þ","ß",
-        "à","á","â","ã","ä","å","æ","ç",
-        "è","é","ê","ë","ì","í","î","ï",
-        "ð","ñ","ò","ó","ô","õ","ö","÷",
-        "ø","ù","ú","û","ü","ý","þ","ÿ"
-    };
-    i32 num=local[1].num();
-    if (0<=num && num<128) {
-        return ngc.newstr((char)num);
-    } else if (128<=num && num<256) {
-        return ngc.newstr(extend[num-128]);
-    }
-    return ngc.newstr(" ");
-}
-
-var builtin_char(var* local, gc& ngc) {
-    return ngc.newstr((unsigned char)local[1].num());
-}
-
-var builtin_values(var* local, gc& ngc) {
-    var hash=local[1];
-    if (hash.type!=vm_hash) {
-        return nas_err("values", "\"hash\" must be hash");
-    }
-    var vec=ngc.alloc(vm_vec);
-    auto& v=vec.vec().elems;
-    for(auto& i:hash.hash().elems) {
-        v.push_back(i.second);
-    }
-    return vec;
-}
-
-var builtin_exists(var* local, gc& ngc) {
-    if (local[1].type!=vm_str) {
-        return zero;
-    }
-    return access(local[1].str().c_str(), F_OK)!=-1?one:zero;
-}
-
-var builtin_open(var* local, gc& ngc) {
-    var name=local[1];
-    var mode=local[2];
-    if (name.type!=vm_str) {
-        return nas_err("open", "\"filename\" must be string");
-    }
-    if (mode.type!=vm_str) {
-        return nas_err("open", "\"mode\" must be string");
-    }
-    FILE* res=fopen(name.str().c_str(), mode.str().c_str());
-    if (!res) {
-        return nas_err("open", "failed to open file <"+name.str()+">");
-    }
-    var ret=ngc.alloc(vm_obj);
-    ret.obj().set(ngc.global_ghost_type_table.ghost_file, res, &ngc.global_ghost_type_table);
-    return ret;
-}
-
-var builtin_close(var* local, gc& ngc) {
-    var fd=local[1];
-    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
-        return nas_err("close", "not a valid filehandle");
-    }
-    fd.obj().clear();
-    return nil;
-}
-
-var builtin_read(var* local, gc& ngc) {
-    var fd=local[1];
-    var buf=local[2];
-    var len=local[3];
-    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
-        return nas_err("read", "not a valid filehandle");
-    }
-    if (buf.type!=vm_str || buf.val.gcobj->unmut) {
-        return nas_err("read", "\"buf\" must be mutable string");
-    }
-    if (len.type!=vm_num) {
-        return nas_err("read", "\"len\" must be number");
-    }
-    if (len.num()<=0 || len.num()>=(1<<30)) {
-        return nas_err("read", "\"len\" less than 1 or too large");
-    }
-    char* buff=new char[(usize)len.num()+1];
-    if (!buff) {
-        return nas_err("read", "malloc failed");
-    }
-    f64 res=fread(buff,1,len.num(), (FILE*)fd.obj().ptr);
-    buf.str()=buff;
-    buf.val.gcobj->unmut=true;
-    delete []buff;
-    return var::num(res);
-}
-
-var builtin_write(var* local, gc& ngc) {
-    var fd=local[1];
-    var str=local[2];
-    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
-        return nas_err("write", "not a valid filehandle");
-    }
-    if (str.type!=vm_str) {
-        return nas_err("write", "\"str\" must be string");
-    }
-    return var::num((f64)fwrite(str.str().c_str(), 1, str.str().length(), (FILE*)fd.obj().ptr));
-}
-
-var builtin_seek(var* local, gc& ngc) {
-    var fd=local[1];
-    var pos=local[2];
-    var whence=local[3];
-    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
-        return nas_err("seek", "not a valid filehandle");
-    }
-    return var::num((f64)fseek((FILE*)fd.obj().ptr, pos.num(), whence.num()));
-}
-
-var builtin_tell(var* local, gc& ngc) {
-    var fd=local[1];
-    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
-        return nas_err("tell", "not a valid filehandle");
-    }
-    return var::num((f64)ftell((FILE*)fd.obj().ptr));
-}
-
-var builtin_readln(var* local, gc& ngc) {
-    var fd=local[1];
-    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
-        return nas_err("readln", "not a valid filehandle");
-    }
-    var str=ngc.alloc(vm_str);
-    char c;
-    while((c=fgetc((FILE*)fd.obj().ptr))!=EOF) {
-        if (c=='\r') {
-            continue;
-        }
-        if (c=='\n') {
-            return str;
-        }
-        str.str()+=c;
-    }
-    if (str.str().length()) {
-        return str;
-    }
-    return nil;
-}
-
-var builtin_stat(var* local, gc& ngc) {
-    var name=local[1];
-    if (name.type!=vm_str) {
-        return nas_err("stat", "\"filename\" must be string");
-    }
-    struct stat buf;
-    if (stat(name.str().c_str(),&buf)<0) {
-        return nas_err("stat", "failed to open file <"+name.str()+">");
-    }
-    var ret=ngc.alloc(vm_vec);
-    ret.vec().elems={
-        var::num((f64)buf.st_dev),
-        var::num((f64)buf.st_ino),
-        var::num((f64)buf.st_mode),
-        var::num((f64)buf.st_nlink),
-        var::num((f64)buf.st_uid),
-        var::num((f64)buf.st_gid),
-        var::num((f64)buf.st_rdev),
-        var::num((f64)buf.st_size),
-        var::num((f64)buf.st_atime),
-        var::num((f64)buf.st_mtime),
-        var::num((f64)buf.st_ctime)
-    };
-    return ret;
-}
-
-var builtin_eof(var* local, gc& ngc) {
-    var fd=local[1];
-    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
-        return nas_err("readln", "not a valid filehandle");
-    }
-    return var::num((f64)feof((FILE*)fd.obj().ptr));
-}
-
-var builtin_fld(var* local, gc& ngc) {
-    // bits.fld(s,0,3);
-    // if s stores 10100010(162)
-    // will get 101(5)
-    var str=local[1];
-    var startbit=local[2];
-    var length=local[3];
-    if (str.type!=vm_str || str.val.gcobj->unmut) {
-        return nas_err("fld", "\"str\" must be mutable string");
-    }
-    if (startbit.type!=vm_num || length.type!=vm_num) {
-        return nas_err("fld", "\"startbit\",\"len\" must be number");
-    }
-    u32 bit=(u32)startbit.num();
-    u32 len=(u32)length.num();
-    if (bit+len>8*str.str().length()) {
-        return nas_err("fld", "bitfield out of bounds");
-    }
-    u32 res=0;
-    auto& s=str.str();
-    for(u32 i=bit;i<bit+len;++i) {
-        if (s[i>>3]&(1<<(7-(i&7)))) {
-            res|=1<<(bit+len-i-1);
-        }
-    }
-    return var::num((f64)res);
-}
-
-var builtin_sfld(var* local, gc& ngc) {
-    // bits.sfld(s,0,3);
-    // if s stores 10100010(162)
-    // will get 101(5) then this will be signed extended to
-    // 11111101(-3)
-    var str=local[1];
-    var startbit=local[2];
-    var length=local[3];
-    if (str.type!=vm_str || str.val.gcobj->unmut) {
-        return nas_err("sfld", "\"str\" must be mutable string");
-    }
-    if (startbit.type!=vm_num || length.type!=vm_num) {
-        return nas_err("sfld", "\"startbit\",\"len\" must be number");
-    }
-    u32 bit=(u32)startbit.num();
-    u32 len=(u32)length.num();
-    if (bit+len>8*str.str().length()) {
-        return nas_err("sfld", "bitfield out of bounds");
-    }
-    u32 res=0;
-    auto& s=str.str();
-    for(u32 i=bit;i<bit+len;++i) {
-        if (s[i>>3]&(1<<(7-(i&7)))) {
-            res|=1<<(bit+len-i-1);
-        }
-    }
-    if (res&(1<<(len-1))) {
-        res|=~((1<<len)-1);
-    }
-    return var::num((f64)((i32)res));
-}
-
-var builtin_setfld(var* local, gc& ngc) {
-    // bits.setfld(s,0,8,69);
-    // set 01000101(69) to string will get this:
-    // 10100010(162)
-    // so s[0]=162
-    var str=local[1];
-    var startbit=local[2];
-    var length=local[3];
-    var value=local[4];
-    if (str.type!=vm_str || str.val.gcobj->unmut) {
-        return nas_err("setfld", "\"str\" must be mutable string");
-    }
-    if (startbit.type!=vm_num || length.type!=vm_num || value.type!=vm_num) {
-        return nas_err("setfld", "\"startbit\",\"len\",\"val\" must be number");
-    }
-    u32 bit=(u32)startbit.num();
-    u32 len=(u32)length.num();
-    u64 val=(u64)value.num();
-    if (bit+len>8*str.str().length()) {
-        return nas_err("setfld", "bitfield out of bounds");
-    }
-    auto& s=str.str();
-    for(u32 i=bit;i<bit+len;++i) {
-        if (val&(1<<(i-bit))) {
-            s[i>>3]|=(1<<(7-(i&7)));
-        } else {
-            s[i>>3]&=~(1<<(7-(i&7)));
-        }
-    }
-    return nil;
-}
-
-var builtin_buf(var* local, gc& ngc) {
-    var length=local[1];
-    if (length.type!=vm_num || length.num()<=0) {
-        return nas_err("buf", "\"len\" must be number greater than 0");
-    }
-    var str=ngc.alloc(vm_str);
-    auto& s=str.str();
-    s.resize(length.num(), '\0');
-    return str;
-}
-
-var builtin_sleep(var* local, gc& ngc) {
-    var val=local[1];
-    if (val.type!=vm_num) {
-        return nil;
-    }
-#if defined(_WIN32) && !defined(_GLIBCXX_HAS_GTHREADS)
-    // mingw-w64 win32 thread model has no std::this_thread
-    // also msvc will use this
-    Sleep(i64(val.num()*1e3));
-#else
-    std::this_thread::sleep_for(std::chrono::microseconds(i64(val.num()*1e6)));
-#endif
-    return nil;
-}
-
-var builtin_pipe(var* local, gc& ngc) {
-#ifndef _WIN32
-    i32 fd[2];
-    var res=ngc.alloc(vm_vec);
-    if (pipe(fd)==-1) {
-        return nas_err("pipe", "failed to create pipe");
-    }
-    res.vec().elems.push_back(var::num((f64)fd[0]));
-    res.vec().elems.push_back(var::num((f64)fd[1]));
-    return res;
-#endif
-    return nas_err("pipe", "not supported");
-}
-
-var builtin_fork(var* local, gc& ngc) {
-#ifndef _WIN32
-    f64 res=fork();
-    if (res<0) {
-        return nas_err("fork", "failed to fork a process");
-    }
-    return var::num((f64)res);
-#endif
-    return nas_err("fork", "not supported");
-}
-
-var builtin_waitpid(var* local, gc& ngc) {
-    var pid=local[1];
-    var nohang=local[2];
-    if (pid.type!=vm_num || nohang.type!=vm_num) {
-        return nas_err("waitpid", "pid and nohang must be number");
-    }
-#ifndef _WIN32
-    i32 ret_pid,status;
-    ret_pid=waitpid(pid.num(),&status,nohang.num()==0?0:WNOHANG);
-    var vec=ngc.alloc(vm_vec);
-    vec.vec().elems.push_back(var::num((f64)ret_pid));
-    vec.vec().elems.push_back(var::num((f64)status));
-    return vec;
-#endif
-    return nas_err("waitpid", "not supported");
-}
-
-var builtin_opendir(var* local, gc& ngc) {
-    var path=local[1];
-    if (path.type!=vm_str) {
-        return nas_err("opendir", "\"path\" must be string");
-    }
-#ifdef _MSC_VER
-    WIN32_FIND_DATAA data;
-    HANDLE p;
-    p=FindFirstFileA((path.str()+"\\*.*").c_str(),&data);
-    if (p==INVALID_HANDLE_VALUE) {
-        return nas_err("opendir", "cannot open dir <"+path.str()+">");
-    }
-#else
-    DIR* p=opendir(path.str().c_str());
-    if (!p) {
-        return nas_err("opendir", "cannot open dir <"+path.str()+">");
-    }
-#endif
-    var ret=ngc.alloc(vm_obj);
-    ret.obj().set(ngc.global_ghost_type_table.ghost_dir, p, &ngc.global_ghost_type_table);
-    return ret;
-}
-
-var builtin_readdir(var* local, gc& ngc) {
-    var handle=local[1];
-    if (!handle.objchk(ngc.global_ghost_type_table.ghost_dir)) {
-        return nas_err("readdir", "not a valid dir handle");
-    }
-#ifdef _MSC_VER
-    WIN32_FIND_DATAA data;
-    if (!FindNextFileA(handle.obj().ptr,&data)) {
-        return nil;
-    }
-    return ngc.newstr(data.cFileName);
-#else
-    dirent* p=readdir((DIR*)handle.obj().ptr);
-    return p?ngc.newstr(p->d_name):nil;
-#endif
-}
-
-var builtin_closedir(var* local, gc& ngc) {
-    var handle=local[1];
-    if (!handle.objchk(ngc.global_ghost_type_table.ghost_dir)) {
-        return nas_err("closedir", "not a valid dir handle");
-    }
-    handle.obj().clear();
-    return nil;
-}
-
-var builtin_chdir(var* local, gc& ngc) {
-    var path=local[1];
-    if (path.type!=vm_str) {
-        return var::num((f64)-1);
-    }
-    return var::num((f64)chdir(path.str().c_str()));
-}
-
-var builtin_environ(var* local, gc& ngc) {
-    var res=ngc.temp=ngc.alloc(vm_vec);
-    auto& vec=res.vec().elems;
-    for(char** env=environ;*env;++env) {
-        vec.push_back(ngc.newstr(*env));
-    }
-    ngc.temp=nil;
-    return res;
-}
-
-var builtin_getcwd(var* local, gc& ngc) {
-    char buf[1024];
-    if (!getcwd(buf,sizeof(buf))) {
-        return nil;
-    }
-    return ngc.newstr(buf);
-}
-
-var builtin_getenv(var* local, gc& ngc) {
-    var envvar=local[1];
-    if (envvar.type!=vm_str) {
-        return nas_err("getenv", "\"envvar\" must be string");
-    }
-    char* res=getenv(envvar.str().c_str());
-    return res?ngc.newstr(res):nil;
-}
-
-var builtin_dlopen(var* local, gc& ngc) {
-    var dlname=local[1];
-    if (dlname.type!=vm_str) {
-        return nas_err("dlopen", "\"libname\" must be string");
-    }
-#ifdef _WIN32
-    wchar_t* str=new wchar_t[dlname.str().size()+1];
-    if (!str) {
-        return nas_err("dlopen", "malloc failed");
-    }
-    memset(str, 0, sizeof(wchar_t)*dlname.str().size()+1);
-    mbstowcs(str, dlname.str().c_str(),dlname.str().size()+1);
-    void* ptr=LoadLibraryA(dlname.str().c_str());
-    delete []str;
-#else
-    void* ptr=dlopen(dlname.str().c_str(), RTLD_LOCAL|RTLD_LAZY);
-#endif
-    if (!ptr) {
-        return nas_err("dlopen", "cannot open dynamic lib <"+dlname.str()+">");
-    }
-    var ret=ngc.temp=ngc.alloc(vm_hash);
-    var lib=ngc.alloc(vm_obj);
-    lib.obj().set(ngc.global_ghost_type_table.ghost_dylib, ptr, &ngc.global_ghost_type_table);
-    ret.hash().elems["lib"]=lib;
-
-#ifdef _WIN32
-    void* func=(void*)GetProcAddress((HMODULE)lib.obj().ptr, "get");
-#else
-    void* func=dlsym(lib.obj().ptr, "get");
-#endif
-    if (!func) {
-        return nas_err("dlopen", "cannot find <get> function");
-    }
-    // get function pointer by name
-    module_func_info* tbl=((get_func_ptr)func)(&ngc.global_ghost_type_table);
-    if (!tbl) {
-        return nas_err("dlopen", "failed to get module functions");
-    }
-    for(u32 i=0;tbl[i].name;++i) {
-        void* p=(void*)tbl[i].fd;
-        var tmp=ngc.alloc(vm_obj);
-        tmp.obj().set(ngc.global_ghost_type_table.ghost_faddr, p, &ngc.global_ghost_type_table);
-        ret.hash().elems[tbl[i].name]=tmp;
-    }
-
-    ngc.temp=nil;
-    return ret;
-}
-
-var builtin_dlclose(var* local, gc& ngc) {
-    var libptr=local[1];
-    if (!libptr.objchk(ngc.global_ghost_type_table.ghost_dylib)) {
-        return nas_err("dlclose", "\"lib\" is not a valid dynamic lib");
-    }
-    libptr.obj().clear();
-    return nil;
-}
-
-var builtin_dlcallv(var* local, gc& ngc) {
-    var fp=local[1];
-    var args=local[2];
-    if (!fp.objchk(ngc.global_ghost_type_table.ghost_faddr)) {
-        return nas_err("dlcall", "\"ptr\" is not a valid function pointer");
-    }
-    auto& vec=args.vec().elems;
-    return ((module_func)fp.obj().ptr)(
-        vec.data(),
-        vec.size(),
-        &ngc
-    );
-}
-
-var builtin_dlcall(var* local, gc& ngc) {
-    var fp=local[1];
-    if (!fp.objchk(ngc.global_ghost_type_table.ghost_faddr)) {
-        return nas_err("dlcall", "\"ptr\" is not a valid function pointer");
-    }
-
-    var* local_frame_start=local+2;
-    usize local_frame_size=ngc.rctx->top-local_frame_start;
-    // arguments' stored place begins at local +2
-    return ((module_func)fp.obj().ptr)(
-        local_frame_start,
-        local_frame_size,
-        &ngc
-    );
-}
-
-var builtin_platform(var* local, gc& ngc) {
-    if (is_windows()) {
-        return ngc.newstr("windows");
-    } else if (is_linux()) {
-        return ngc.newstr("linux");
-    } else if (is_macos()) {
-        return ngc.newstr("macOS");
-    }
-    return ngc.newstr("unknown");
-}
-
-var builtin_arch(var* local, gc& ngc) {
-    if (is_x86()) {
-        return ngc.newstr("x86");
-    } else if (is_x86_64()) {
-        return ngc.newstr("x86-64");
-    } else if (is_amd64()) {
-        return ngc.newstr("amd64");
-    } else if (is_arm()) {
-        return ngc.newstr("arm");
-    } else if (is_aarch64()) {
-        return ngc.newstr("aarch64");
-    } else if (is_ia64()) {
-        return ngc.newstr("ia64");
-    } else if (is_powerpc()) {
-        return ngc.newstr("powerpc");
-    } else if (is_superh()) {
-        return ngc.newstr("superh");
-    }
-    return ngc.newstr("unknown");
-}
-
-// md5 related functions
-string tohex(u32 num) {
-    const char str16[]="0123456789abcdef";
-    string str="";
-    for(u32 i=0;i<4;i++, num>>=8) {
-        string tmp="";
-        for(u32 j=0,b=num&0xff;j<2;j++,b>>=4) {
-            tmp.insert(0,1,str16[b&0xf]);
-        }
-        str+=tmp;
-    }
-    return str;
-}
-
-string md5(const string& src) {
-    std::vector<u32> buff;
-    usize num=((src.length()+8)>>6)+1;
-    usize buffsize=num<<4;
-    buff.resize(buffsize,0);
-    for(usize i=0;i<src.length();i++) {
-        buff[i>>2]|=((u8)src[i])<<((i&0x3)<<3);
-    }
-    buff[src.length()>>2]|=0x80<<(((src.length()%4))<<3);
-    buff[buffsize-2]=(src.length()<<3)&0xffffffff;
-    buff[buffsize-1]=((src.length()<<3)>>32)&0xffffffff;
-
-    // u32(abs(sin(i+1))*(2pow32))
-    const u32 k[]={
-        0xd76aa478,0xe8c7b756,0x242070db,0xc1bdceee,0xf57c0faf,0x4787c62a,0xa8304613,0xfd469501,
-        0x698098d8,0x8b44f7af,0xffff5bb1,0x895cd7be,0x6b901122,0xfd987193,0xa679438e,0x49b40821,
-        0xf61e2562,0xc040b340,0x265e5a51,0xe9b6c7aa,0xd62f105d,0x02441453,0xd8a1e681,0xe7d3fbc8,
-        0x21e1cde6,0xc33707d6,0xf4d50d87,0x455a14ed,0xa9e3e905,0xfcefa3f8,0x676f02d9,0x8d2a4c8a,
-        0xfffa3942,0x8771f681,0x6d9d6122,0xfde5380c,0xa4beea44,0x4bdecfa9,0xf6bb4b60,0xbebfbc70,
-        0x289b7ec6,0xeaa127fa,0xd4ef3085,0x04881d05,0xd9d4d039,0xe6db99e5,0x1fa27cf8,0xc4ac5665,
-        0xf4292244,0x432aff97,0xab9423a7,0xfc93a039,0x655b59c3,0x8f0ccc92,0xffeff47d,0x85845dd1,
-        0x6fa87e4f,0xfe2ce6e0,0xa3014314,0x4e0811a1,0xf7537e82,0xbd3af235,0x2ad7d2bb,0xeb86d391
-    };
-
-    // left shift bits
-    const u32 s[]={
-        7,12,17,22,7,12,17,22,7,12,17,22,7,12,17,22,
-        5,9,14,20,5,9,14,20,5,9,14,20,5,9,14,20,
-        4,11,16,23,4,11,16,23,4,11,16,23,4,11,16,23,
-        6,10,15,21,6,10,15,21,6,10,15,21,6,10,15,21
-    };
-
-    // index
-    const u32 idx[]={
-        0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, // g=i
-        1,6,11,0,5,10,15,4,9,14,3,8,13,2,7,12, // g=(5*i+1)%16;
-        5,8,11,14,1,4,7,10,13,0,3,6,9,12,15,2, // g=(3*i+5)%16;
-        0,7,14,5,12,3,10,1,8,15,6,13,4,11,2,9  // g=(7*i)%16;
-    };
-    
-#define shift(x,n)  (((x)<<(n))|((x)>>(32-(n)))) // cycle left shift
-#define md5f(x,y,z) (((x)&(y))|((~x)&(z)))    
-#define md5g(x,y,z) (((x)&(z))|((y)&(~z)))
-#define md5h(x,y,z) ((x)^(y)^(z))
-#define md5i(x,y,z) ((y)^((x)|(~z)))
-    
-    u32 atmp=0x67452301,btmp=0xefcdab89;
-    u32 ctmp=0x98badcfe,dtmp=0x10325476;
-    for(u32 i=0;i<buffsize;i+=16) {
-        u32 f,a=atmp,b=btmp,c=ctmp,d=dtmp;
-        for(u32 j=0;j<64;j++) {
-            if (j<16)      f=md5f(b,c,d);
-            else if (j<32) f=md5g(b,c,d);
-            else if (j<48) f=md5h(b,c,d);
-            else           f=md5i(b,c,d);
-            u32 tmp=d;
-            d=c;
-            c=b;
-            b=b+shift((a+f+k[j]+buff[i+idx[j]]),s[j]);
-            a=tmp;
-        }
-        atmp+=a;
-        btmp+=b;
-        ctmp+=c;
-        dtmp+=d;
-    }
-    return tohex(atmp)+tohex(btmp)+tohex(ctmp)+tohex(dtmp);
-}
-
-var builtin_md5(var* local, gc& ngc) {
-    var str=local[1];
-    if (str.type!=vm_str) {
-        return nas_err("md5", "\"str\" must be string");
-    }
-    return ngc.newstr(md5(str.str()));
-}
-
-var builtin_cocreate(var* local, gc& ngc) {
-    // +-------------+
-    // | old pc      | <- top[0]
-    // +-------------+
-    // | old localr  | <- top[-1]
-    // +-------------+
-    // | old upvalr  | <- top[-2]
-    // +-------------+
-    // | local scope |
-    // | ...         |
-    // +-------------+ <- local pointer stored in localr
-    // | old funcr   | <- old function stored in funcr
-    // +-------------+
-    var func=local[1];
-    if (func.type!=vm_func) {
-        return nas_err("coroutine::create", "must use a function to create coroutine");
-    }
-    if (ngc.cort) {
-        return nas_err("coroutine::create", "cannot create another coroutine in a coroutine");
-    }
-    var co=ngc.alloc(vm_co);
-    nas_co& cort=co.co();
-    cort.ctx.pc=func.func().entry-1;
-
-    cort.ctx.top[0]=nil;
-    cort.ctx.localr=cort.ctx.top+1;
-    cort.ctx.top=cort.ctx.localr+func.func().lsize;
-    cort.ctx.localr[0]=func.func().local[0];
-    cort.ctx.top[0]=nil; // old upvalr
-    cort.ctx.top++;
-    cort.ctx.top[0]=var::addr((var*)nullptr); // old localr
-    cort.ctx.top++;
-    cort.ctx.top[0]=var::ret(0); // old pc, set to zero to make op_ret recognizing this as coroutine function
-
-    cort.ctx.funcr=func; // make sure the coroutine function can use correct upvalues
-    cort.status=coroutine_status::suspended;
-    
-    return co;
-}
-
-var builtin_coresume(var* local, gc& ngc) {
-    if (ngc.cort) {
-        return nas_err("coroutine::resume", "cannot start another coroutine when one is running");
-    }
-    var co=local[1];
-    // return nil if is not a coroutine object
-    if (co.type!=vm_co) {
-        return nil;
-    }
-    // cannot resume a dead coroutine
-    if (co.co().status==coroutine_status::dead) {
-        return nil;
-    }
-
-    // change to coroutine context
-    ngc.ctxchg(co.co());
-
-    // fetch coroutine's stack top and return
-    // so the coroutine's stack top in fact is not changed
-    if (ngc.rctx->top[0].type==vm_ret) {
-        // when first calling this coroutine, the stack top must be vm_ret
-        return ngc.rctx->top[0];
-    }
-
-    // after first calling the coroutine, each time coroutine.yield triggered
-    // a new space will be reserved on stack with value nil
-    // so we could fill this place with args
-
-    // the coroutine seems like coroutine.yield returns the value
-    // but in fact coroutine.yield stop the coroutine
-    // until main context calls the coroutine.resume
-    return local[2];
-}
-
-var builtin_coyield(var* local, gc& ngc) {
-    if (!ngc.cort) {
-        return nas_err("coroutine::yield", "no coroutine is running");
-    }
-
-    // this will set to main stack top
-    ngc.ctxreserve();
-    
-    // then this will return value to main's stack top[0]
-    // the procedure seems like coroutine.resume returns the value
-    // but in fact coroutine.resume stop the main context
-    // until coroutine calls the coroutine.yield
-    return local[1];
-}
-
-var builtin_costatus(var* local, gc& ngc) {
-    var co=local[1];
-    if (co.type!=vm_co) {
-        return ngc.newstr("error");
-    }
-    switch(co.co().status) {
-        case coroutine_status::suspended: return ngc.newstr("suspended");break;
-        case coroutine_status::running:   return ngc.newstr("running");  break;
-        case coroutine_status::dead:      return ngc.newstr("dead");     break;
-    }
-    return nil;
-}
-
-var builtin_corun(var* local, gc& ngc) {
-    return ngc.cort?one:zero;
-}
-
-var builtin_millisec(var* local, gc& ngc) {
-    f64 res=std::chrono::duration_cast<std::chrono::milliseconds>
-            (std::chrono::high_resolution_clock::now().time_since_epoch())
-            .count();
-    return var::num(res);
-}
-
-var builtin_sysargv(var* local, gc& ngc) {
-    var res=ngc.alloc(vm_vec);
-    res.vec().elems=ngc.env_argv;
-    return res;
-}
-
-var builtin_gcextend(var* local, gc& ngc) {
-    var type=local[1];
-    if (type.type!=vm_str) {
-        return nil;
-    }
-    auto& s=type.str();
-    if (s=="str") {
-        ngc.extend(vm_str);
-    } else if (s=="vec") {
-        ngc.extend(vm_vec);
-    } else if (s=="hash") {
-        ngc.extend(vm_hash);
-    } else if (s=="func") {
-        ngc.extend(vm_func);
-    } else if (s=="upval") {
-        ngc.extend(vm_upval);
-    } else if (s=="obj") {
-        ngc.extend(vm_obj);
-    } else if (s=="co") {
-        ngc.extend(vm_co);
-    }
-    return nil;
-}
-
-var builtin_logtime(var* local, gc& ngc) {
-    time_t t=time(nullptr);
-    tm* tm_t=localtime(&t);
-    char s[64];
-    snprintf(
-        s,64,"%d-%.2d-%.2d %.2d:%.2d:%.2d",
-        tm_t->tm_year+1900,
-        tm_t->tm_mon+1,
-        tm_t->tm_mday,
-        tm_t->tm_hour,
-        tm_t->tm_min,
-        tm_t->tm_sec
-    );
-    return ngc.newstr(s);
-}
-
-var builtin_ghosttype(var* local, gc& ngc) {
-    var arg = local[1];
-    if (arg.type!=vm_obj) {
-        return nas_err("ghosttype", "this is not a ghost object.");
-    }
-    const auto& name = arg.obj().get_ghost_name();
-    if (!name.length()) {
-        return var::num((u64)arg.obj().ptr);
-    }
-    return ngc.newstr(name);
-}
-
-// register builtin function's name and it's address here in this table below
-// this table must end with {nullptr,nullptr}
-struct {
-    const char* name;
-    var (*func)(var*,gc&);
-} builtin[]= {
-    {"__print",   builtin_print   },
-    {"__println", builtin_println },
-    {"__exit",    builtin_exit    },
-    {"__abort",   builtin_abort   },
-    {"__append",  builtin_append  },
-    {"__setsize", builtin_setsize },
-    {"__system",  builtin_system  },
-    {"__input",   builtin_input   },
-    {"__readfile",builtin_readfile},
-    {"__fout",    builtin_fout    },
-    {"__split",   builtin_split   },
-    {"__rand",    builtin_rand    },
-    {"__id",      builtin_id      },
-    {"__int",     builtin_int     },
-    {"__floor",   builtin_floor   },
-    {"__num",     builtin_num     },
-    {"__pop",     builtin_pop     },
-    {"__str",     builtin_str     },
-    {"__size",    builtin_size    },
-    {"__u32xor",  builtin_u32xor  },
-    {"__u32and",  builtin_u32and  },
-    {"__u32or",   builtin_u32or   },
-    {"__u32nand", builtin_u32nand },
-    {"__u32not",  builtin_u32not  },
-    {"__pow",     builtin_pow     },
-    {"__sin",     builtin_sin     },
-    {"__cos",     builtin_cos     },
-    {"__tan",     builtin_tan     },
-    {"__exp",     builtin_exp     },
-    {"__lg",      builtin_lg      },
-    {"__ln",      builtin_ln      },
-    {"__sqrt",    builtin_sqrt    },
-    {"__atan2",   builtin_atan2   },
-    {"__isnan",   builtin_isnan   },
-    {"__time",    builtin_time    },
-    {"__contains",builtin_contains},
-    {"__delete",  builtin_delete  },
-    {"__keys",    builtin_keys    },
-    {"__die",     builtin_die     },
-    {"__find",    builtin_find    },
-    {"__type",    builtin_type    },
-    {"__substr",  builtin_substr  },
-    {"__streq",   builtin_streq   },
-    {"__left",    builtin_left    },
-    {"__right",   builtin_right   },
-    {"__cmp",     builtin_cmp     },
-    {"__chr",     builtin_chr     },
-    {"__char",    builtin_char    },
-    {"__values",  builtin_values  },
-    {"__exists",  builtin_exists  },
-    {"__open",    builtin_open    },
-    {"__close",   builtin_close   },
-    {"__read",    builtin_read    },
-    {"__write",   builtin_write   },
-    {"__seek",    builtin_seek    },
-    {"__tell",    builtin_tell    },
-    {"__readln",  builtin_readln  },
-    {"__stat",    builtin_stat    },
-    {"__eof",     builtin_eof     },
-    {"__fld",     builtin_fld     },
-    {"__sfld",    builtin_sfld    },
-    {"__setfld",  builtin_setfld  },
-    {"__buf",     builtin_buf     },
-    {"__sleep",   builtin_sleep   },
-    {"__pipe",    builtin_pipe    },
-    {"__fork",    builtin_fork    },
-    {"__waitpid", builtin_waitpid },
-    {"__opendir", builtin_opendir },
-    {"__readdir", builtin_readdir },
-    {"__closedir",builtin_closedir},
-    {"__chdir",   builtin_chdir   },
-    {"__environ", builtin_environ },
-    {"__getcwd",  builtin_getcwd  },
-    {"__getenv",  builtin_getenv  },
-    {"__dlopen",  builtin_dlopen  },
-    {"__dlclose", builtin_dlclose },
-    {"__dlcallv", builtin_dlcallv },
-    {"__dlcall",  builtin_dlcall  },
-    {"__platform",builtin_platform},
-    {"__arch",    builtin_arch    },
-    {"__md5",     builtin_md5     },
-    {"__cocreate",builtin_cocreate},
-    {"__coresume",builtin_coresume},
-    {"__coyield", builtin_coyield },
-    {"__costatus",builtin_costatus},
-    {"__corun"   ,builtin_corun   },
-    {"__millisec",builtin_millisec},
-    {"__sysargv", builtin_sysargv },
-    {"__gcextd",  builtin_gcextend},
-    {"__logtime", builtin_logtime },
-    {"__ghosttype", builtin_ghosttype},
-    {nullptr,     nullptr         }
-};
diff --git a/nasal_codegen.h b/nasal_codegen.h
deleted file mode 100644
index 0fbd9ab..0000000
--- a/nasal_codegen.h
+++ /dev/null
@@ -1,1088 +0,0 @@
-#pragma once
-
-#include "nasal_err.h"
-#include "nasal_builtin.h"
-#include "nasal_opcode.h"
-#include "nasal_ast.h"
-#include "nasal_parse.h"
-#include "nasal_import.h"
-
-#include <iomanip>
-#include <list>
-#include <stack>
-#include <unordered_map>
-
-#ifdef _MSC_VER
-#pragma warning (disable:4244)
-#pragma warning (disable:4267)
-#endif
-
-class codegen {
-private:
-    u16 fileindex;
-    error& err;
-    const string* file;
-    std::stack<u32> in_iterloop;
-    std::unordered_map<f64,u32> num_table;
-    std::unordered_map<string,u32> str_table;
-    std::vector<f64> num_res;
-    std::vector<string> str_res;
-    std::vector<opcode> code;
-    std::list<std::vector<i32>> continue_ptr;
-    std::list<std::vector<i32>> break_ptr;
-
-    // symbol table
-    // global : max STACK_DEPTH-1 values
-    std::unordered_map<string,i32> global;
-    // local  : max 32768 upvalues 65536 values
-    // but in fact local scope also has less than STACK_DEPTH value
-    std::list<std::unordered_map<string,i32>> local;
-
-    bool check_memory_reachable(const ast&);
-    void check_id_exist(const ast&);
-    
-    void die(const string& info, const span& loc) {
-        err.err("code", loc, info);
-    }
-
-    void regist_num(const f64);
-    void regist_str(const string&);
-    void find_symbol(const ast&);
-    void add_sym(const string&);
-    i32 local_find(const string&);
-    i32 global_find(const string&);
-    i32 upvalue_find(const string&);
-
-    void gen(u8, u32, u32);
-
-    void num_gen(const ast&);
-    void str_gen(const ast&);
-    void bool_gen(const ast&);
-    void vec_gen(const ast&);
-    void hash_gen(const ast&);
-    void func_gen(const ast&);
-    void call_gen(const ast&);
-    void call_id(const ast&);
-    void call_hash(const ast&);
-    void call_vec(const ast&);
-    void call_func(const ast&);
-    void mcall(const ast&);
-    void mcall_id(const ast&);
-    void mcall_vec(const ast&);
-    void mcall_hash(const ast&);
-    void multi_def(const ast&);
-    void single_def(const ast&);
-    void def_gen(const ast&);
-    void multi_assign_gen(const ast&);
-    void cond_gen(const ast&);
-    void loop_gen(const ast&);
-    void load_continue_break(i32, i32);
-    void while_gen(const ast&);
-    void for_gen(const ast&);
-    void expr_gen(const ast&);
-    void forindex_gen(const ast&);
-    void foreach_gen(const ast&);
-    void or_gen(const ast&);
-    void and_gen(const ast&);
-    void trino_gen(const ast&);
-    void calc_gen(const ast&);
-    void block_gen(const ast&);
-    void ret_gen(const ast&);
-
-public:
-    codegen(error& e): fileindex(0), err(e), file(nullptr) {}
-    const error& compile(const parse&, const linker&);
-    void print();
-    const std::vector<string>& strs()  const {return str_res;}
-    const std::vector<f64>&    nums()  const {return num_res;}
-    const std::vector<opcode>& codes() const {return code;}
-};
-
-bool codegen::check_memory_reachable(const ast& node) {
-    if (node.type()==ast_call) {
-        const ast& tmp=node.child().back();
-        if (tmp.type()==ast_callf) {
-            die("bad left-value with function call", node.location());
-            return false;
-        }
-        if (tmp.type()==ast_callv && (tmp.size()!=1 || tmp[0].type()==ast_subvec)) {
-            die("bad left-value with subvec", node.location());
-            return false;
-        }
-    } else if (node.type()!=ast_id) {
-        die("bad left-value", node.location());
-        return false;
-    }
-    return true;
-}
-
-void codegen::check_id_exist(const ast& node) {
-    const string& str=node.str();
-    for(u32 i=0;builtin[i].name;++i) {
-        if (builtin[i].name==str) {
-            if (local.empty()) {
-                die("useless native function used in global scope", node.location());
-            }
-            return;
-        }
-    }
-
-    if (local_find(str)>=0) {
-        return;
-    }
-    if (upvalue_find(str)>=0) {
-        return;
-    }
-    if (global_find(str)>=0) {
-        return;
-    }
-    die("undefined symbol \""+str+"\", and this symbol is useless here", node.location());
-}
-
-void codegen::regist_num(const f64 num) {
-    if (!num_table.count(num)) {
-        u32 size=num_table.size();
-        num_table[num]=size;
-        num_res.push_back(num);
-    }
-}
-
-void codegen::regist_str(const string& str) {
-    if (!str_table.count(str)) {
-        u32 size=str_table.size();
-        str_table[str]=size;
-        str_res.push_back(str);
-    }
-}
-
-void codegen::find_symbol(const ast& node) {
-    // symbol definition checked here
-    // if find a function, return
-    if (node.type()==ast_func) {
-        return;
-    } else if (node.type()==ast_def) { // find definition, check
-        if (node[0].type()==ast_multi_id) {
-            for(auto& i:node[0].child()) {
-                add_sym(i.str());
-            }
-        } else {
-            add_sym(node[0].str());
-        }
-        find_symbol(node[1]);
-    } else if (node.type()==ast_iter) { // find iterator(foreach, forindex), check
-        add_sym(node[0].str());
-    } else { // check children
-        for(auto& i:node.child()) {
-            find_symbol(i);
-        }
-    }
-}
-
-void codegen::add_sym(const string& name) {
-    if (local.empty()) {
-        if (global.count(name)) {
-            return;
-        }
-        i32 index=global.size();
-        global[name]=index;
-        return;
-    }
-    if (local.back().count(name)) {
-        return;
-    }
-    i32 index=local.back().size();
-    local.back()[name]=index;
-}
-
-i32 codegen::local_find(const string& name) {
-    if (local.empty()) {
-        return -1;
-    }
-    return local.back().count(name)?local.back()[name]:-1;
-}
-
-i32 codegen::global_find(const string& name) {
-    return global.count(name)?global[name]:-1;
-}
-
-i32 codegen::upvalue_find(const string& name) {
-    // 32768 level 65536 upvalues
-    i32 index=-1;
-    usize size=local.size();
-    if (size<=1) {
-        return -1;
-    }
-    auto iter=local.begin();
-    for(u32 i=0;i<size-1;++i,++iter) {
-        if (iter->count(name)) {
-            index=((i<<16)|(*iter)[name]);
-        }
-    }
-    return index;
-}
-
-void codegen::gen(u8 op, u32 num, u32 line) {
-    code.push_back({op, fileindex, num, line});
-}
-
-void codegen::num_gen(const ast& node) {
-    f64 num=node.num();
-    regist_num(num);
-    gen(op_pnum,num_table[num], node.line());
-}
-
-void codegen::str_gen(const ast& node) {
-    regist_str(node.str());
-    gen(op_pstr, str_table[node.str()], node.line());
-}
-
-void codegen::bool_gen(const ast& node) {
-    f64 num=node.str()=="true"?1:0;
-    regist_num(num);
-    gen(op_pnum, num_table[num], node.line());
-}
-
-void codegen::vec_gen(const ast& node) {
-    for(auto& child:node.child()) {
-        calc_gen(child);
-    }
-    gen(op_newv, node.size(), node.line());
-}
-
-void codegen::hash_gen(const ast& node) {
-    gen(op_newh, 0, node.line());
-    for(auto& child:node.child()) {
-        calc_gen(child[1]);
-        const string& str=child[0].str();
-        regist_str(str);
-        gen(op_happ, str_table[str], child.line());
-    }
-}
-
-void codegen::func_gen(const ast& node) {
-    // parameter list format check
-    bool checked_default=false;
-    bool checked_dynamic=false;
-    std::unordered_map<string,bool> argname;
-    for(auto& tmp:node[0].child()) {
-        if (tmp.type()==ast_default) {
-            checked_default=true;
-        } else if (tmp.type()==ast_dynamic) {
-            checked_dynamic=true;
-        }
-        // check default parameter and dynamic parameter
-        if (checked_default && tmp.type()!=ast_default) {
-            die("must use default parameters here", tmp.location());
-        }
-        if (checked_dynamic && &tmp!=&node[0].child().back()) {
-            die("dynamic parameter must be the last one", tmp.location());
-        }
-        // check redefinition
-        string name=tmp.str();
-        if (argname.count(name)) {
-            die("redefinition of parameter: "+name, tmp.location());
-        } else {
-            argname[name]=true;
-        }
-    }
-
-    usize newf=code.size();
-    gen(op_newf, 0, node.line());
-    usize lsize=code.size();
-    gen(op_intl, 0, node.line());
-    
-    // add special keyword 'me' into symbol table
-    // this symbol is only used in local scope(function's scope)
-    // this keyword is set to nil as default value
-    // after calling a hash, this keyword is set to this hash
-    // this symbol's index will be 0
-    local.push_back({{"me", 0}});
-
-    // generate parameter list
-    for(auto& tmp:node[0].child()) {
-        const string& str=tmp.str();
-        if (str=="me") {
-            die("\"me\" should not be a parameter", tmp.location());
-        }
-        regist_str(str);
-        switch(tmp.type()) {
-            case ast_id:
-                gen(op_para, str_table[str], tmp.line());
-                break;
-            case ast_default:
-                calc_gen(tmp[0]);
-                gen(op_deft, str_table[str], tmp.line());
-                break;
-            case ast_dynamic:
-                gen(op_dyn, str_table[str], tmp.line());
-                break;
-        }
-        add_sym(str);
-    }
-
-    code[newf].num=code.size()+1; // entry
-    usize jmp_ptr=code.size();
-    gen(op_jmp, 0, node.line());
-
-    const ast& block=node[1];
-    // search symbols first, must use after loading parameters
-    // or the location of symbols will change and cause fatal error
-    find_symbol(block);
-    in_iterloop.push(0);
-    block_gen(block);
-    in_iterloop.pop();
-    code[lsize].num=local.back().size();
-    if (local.back().size()>=STACK_DEPTH) {
-        die("too many local variants: "+std::to_string(local.back().size()), block.location());
-    }
-    local.pop_back();
-
-    if (!block.size() || block.child().back().type()!=ast_ret) {
-        gen(op_pnil, 0, block.line());
-        gen(op_ret, 0, block.line());
-    }
-    code[jmp_ptr].num=code.size();
-}
-
-void codegen::call_gen(const ast& node) {
-    calc_gen(node[0]);
-    if (code.back().op==op_callb) {
-        return;
-    }
-    for(usize i=1;i<node.size();++i) {
-        const ast& tmp=node[i];
-        switch(tmp.type()) {
-            case ast_callh:call_hash(tmp);break;
-            case ast_callv:call_vec(tmp); break;
-            case ast_callf:call_func(tmp);break;
-        }
-    }
-}
-
-void codegen::call_id(const ast& node) {
-    const string& str=node.str();
-    for(u32 i=0;builtin[i].name;++i) {
-        if (builtin[i].name==str) {
-            gen(op_callb, i, node.line());
-            if (local.empty()) {
-                die("should warp native function in local scope", node.location());
-            }
-            return;
-        }
-    }
-    i32 index;
-    if ((index=local_find(str))>=0) {
-        gen(op_calll, index, node.line());
-        return;
-    }
-    if ((index=upvalue_find(str))>=0) {
-        gen(op_upval, index, node.line());
-        return;
-    }
-    if ((index=global_find(str))>=0) {
-        gen(op_callg, index, node.line());
-        return;
-    }
-    die("undefined symbol \""+str+"\"", node.location());
-}
-
-void codegen::call_hash(const ast& node) {
-    regist_str(node.str());
-    gen(op_callh, str_table[node.str()], node.line());
-}
-
-void codegen::call_vec(const ast& node) {
-    // maybe this place can use callv-const if ast's first child is ast_num
-    if (node.size()==1 && node[0].type()!=ast_subvec) {
-        calc_gen(node[0]);
-        gen(op_callv, 0, node[0].line());
-        return;
-    }
-    gen(op_slcbeg,0,node.line());
-    for(auto& tmp:node.child()) {
-        if (tmp.type()!=ast_subvec) {
-            calc_gen(tmp);
-            gen(op_slc, 0, tmp.line());
-        } else {
-            calc_gen(tmp[0]);
-            calc_gen(tmp[1]);
-            gen(op_slc2, 0, tmp.line());
-        }
-    }
-    gen(op_slcend, 0, node.line());
-}
-
-void codegen::call_func(const ast& node) {
-    if (!node.size() || node[0].type()!=ast_pair) {
-        for(auto& child:node.child()) {
-            calc_gen(child);
-        }
-        gen(op_callfv, node.size(), node.line());
-    } else if (node[0].type()==ast_pair) {
-        hash_gen(node);
-        gen(op_callfh, 0, node.line());
-    }
-}
-
-/* mcall should run after calc_gen because this operation may trigger gc.
-*  to avoid gc incorrectly collecting values that include the memory space(which will cause SIGSEGV),
-*  we must run ast[1] then we run ast[0] to get the memory space.
-*  at this time the value including the memory space can must be found alive.
-*  BUT in fact this method does not make much safety.
-*  so we use another way to avoid gc-caused SIGSEGV: reserve m-called value on stack.
-*  you could see the notes in `vm::opr_mcallv()`.
-*/
-void codegen::mcall(const ast& node) {
-    if (!check_memory_reachable(node)) {
-        return;
-    }
-    if (node.type()==ast_id) {
-        mcall_id(node);
-        return;
-    }
-    if (node.size()==1) { // foreach and forindex use call-id ast to get mcall
-        mcall_id(node[0]);
-        return;
-    }
-    calc_gen(node[0]);
-    for(usize i=1;i<node.size()-1;++i) {
-        const ast& tmp=node[i];
-        switch(tmp.type()) {
-            case ast_callh:call_hash(tmp);break;
-            case ast_callv:call_vec(tmp); break;
-            case ast_callf:call_func(tmp);break;
-        }
-    }
-    const ast& tmp=node.child().back();
-    if (tmp.type()==ast_callh) {
-        mcall_hash(tmp);
-    } else if (tmp.type()==ast_callv) {
-        mcall_vec(tmp);
-    }
-}
-
-void codegen::mcall_id(const ast& node) {
-    const string& str=node.str();
-    for(u32 i=0;builtin[i].name;++i) {
-        if (builtin[i].name==str) {
-            die("cannot modify native function", node.location());
-            return;
-        }
-    }
-    i32 index;
-    if ((index=local_find(str))>=0) {
-        gen(op_mcalll, index, node.line());
-        return;
-    }
-    if ((index=upvalue_find(str))>=0) {
-        gen(op_mupval, index, node.line());
-        return;
-    }
-    if ((index=global_find(str))>=0) {
-        gen(op_mcallg, index, node.line());
-        return;
-    }
-    die("undefined symbol \""+str+"\"", node.location());
-}
-
-void codegen::mcall_vec(const ast& node) {
-    calc_gen(node[0]);
-    gen(op_mcallv, 0, node.line());
-}
-
-void codegen::mcall_hash(const ast& node) {
-    regist_str(node.str());
-    gen(op_mcallh, str_table[node.str()], node.line());
-}
-
-void codegen::single_def(const ast& node) {
-    const string& str=node[0].str();
-    calc_gen(node[1]);
-    local.empty()?
-        gen(op_loadg, global_find(str), node.line()):
-        gen(op_loadl, local_find(str), node.line());
-}
-void codegen::multi_def(const ast& node) {
-    auto& ids=node[0].child();
-    usize size=ids.size();
-    if (node[1].type()==ast_tuple) { // (var a,b,c)=(c,b,a);
-        auto& vals=node[1].child();
-        for(usize i=0;i<size;++i) {
-            // check node type, only identifier is allowed
-            if (ids[i].type()!=ast_id) {
-                die("cannot call identifier in multi-definition", ids[i].location());
-                continue;
-            }
-            calc_gen(vals[i]);
-            const string& str=ids[i].str();
-            local.empty()?
-                gen(op_loadg, global_find(str), ids[i].line()):
-                gen(op_loadl, local_find(str), ids[i].line());
-        }
-    } else { // (var a,b,c)=[0,1,2];
-        calc_gen(node[1]);
-        for(usize i=0;i<size;++i) {
-            // check node type, only identifier is allowed
-            if (ids[i].type()!=ast_id) {
-                die("cannot call identifier in multi-definition", ids[i].location());
-                continue;
-            }
-            gen(op_callvi, i, node[1].line());
-            const string& str=ids[i].str();
-            local.empty()?
-                gen(op_loadg, global_find(str), ids[i].line()):
-                gen(op_loadl, local_find(str), ids[i].line());
-        }
-        gen(op_pop, 0, node.line());
-    }
-}
-
-void codegen::def_gen(const ast& node) {
-    if (node[0].type()==ast_id && node[1].type()==ast_tuple) {
-        die("cannot accept too many values", node[1].location());
-    } else if (node[0].type()==ast_multi_id && node[1].type()==ast_tuple && node[0].size()<node[1].size()) {
-        die("lack values in multi-definition", node[1].location());
-    } else if (node[0].type()==ast_multi_id && node[1].type()==ast_tuple && node[0].size()>node[1].size()) {
-        die("too many values in multi-definition", node[1].location());
-    }
-    node[0].type()==ast_id?single_def(node):multi_def(node);
-}
-
-void codegen::multi_assign_gen(const ast& node) {
-    if (node[1].type()==ast_tuple && node[0].size()<node[1].size()) {
-        die("lack values in multi-assignment", node[1].location());
-    } else if (node[1].type()==ast_tuple && node[0].size()>node[1].size()) {
-        die("too many values in multi-assignment", node[1].location());
-    }
-    i32 size=node[0].size();
-    if (node[1].type()==ast_tuple) {
-        for(i32 i=size-1;i>=0;--i) {
-            calc_gen(node[1][i]);
-        }
-        for(i32 i=0;i<size;++i) {
-            mcall(node[0][i]);
-            // multi assign user loadl and loadg to avoid meq's stack--
-            // and this operation changes local and global value directly
-            if (code.back().op==op_mcalll) {
-                code.back().op=op_loadl;
-            } else if (code.back().op==op_mupval) {
-                code.back().op=op_loadu;
-            } else if (code.back().op==op_mcallg) {
-                code.back().op=op_loadg;
-            } else {
-                gen(op_meq, 1, node[0][i].line());
-            }
-        }
-    } else {
-        calc_gen(node[1]);
-        for(i32 i=0;i<size;++i) {
-            gen(op_callvi, i, node[1].line());
-            // multi assign user loadl and loadg to avoid meq's stack--
-            // and this operation changes local and global value directly
-            mcall(node[0][i]);
-            if (code.back().op==op_mcalll) {
-                code.back().op=op_loadl;
-            } else if (code.back().op==op_mupval) {
-                code.back().op=op_loadu;
-            } else if (code.back().op==op_mcallg) {
-                code.back().op=op_loadg;
-            } else {
-                gen(op_meq, 1, node[0][i].line());
-            }
-        }
-        gen(op_pop, 0, node.line());
-    }
-}
-
-void codegen::cond_gen(const ast& node) {
-    std::vector<usize> jmp_label;
-    for(auto& tmp:node.child()) {
-        if (tmp.type()==ast_if || tmp.type()==ast_elsif) {
-            calc_gen(tmp[0]);
-            usize ptr=code.size();
-            gen(op_jf, 0, tmp.line());
-            block_gen(tmp[1]);
-            // without 'else' the last condition doesn't need to jmp
-            if (&tmp!=&node.child().back()) {
-                jmp_label.push_back(code.size());
-                gen(op_jmp, 0, tmp.line());
-            }
-            code[ptr].num=code.size();
-        } else {
-            block_gen(tmp[0]);
-            break;
-        }
-    }
-    for(auto i:jmp_label) {
-        code[i].num=code.size();
-    }
-}
-
-void codegen::loop_gen(const ast& node) {
-    continue_ptr.push_front({});
-    break_ptr.push_front({});
-    switch(node.type()) {
-        case ast_while:   while_gen(node);   break;
-        case ast_for:     for_gen(node);     break;
-        case ast_forindex:forindex_gen(node);break;
-        case ast_foreach: foreach_gen(node); break;
-    }
-}
-
-void codegen::load_continue_break(i32 continue_place,i32 break_place) {
-    for(auto i:continue_ptr.front()) {
-        code[i].num=continue_place;
-    }
-    for(auto i:break_ptr.front()) {
-        code[i].num=break_place;
-    }
-    continue_ptr.pop_front();
-    break_ptr.pop_front();
-}
-
-void codegen::while_gen(const ast& node) {
-    usize loop_ptr=code.size();
-    calc_gen(node[0]);
-    usize condition_ptr=code.size();
-    gen(op_jf, 0, node[0].line());
-
-    block_gen(node[1]);
-    gen(op_jmp, loop_ptr, node[1].line());
-    code[condition_ptr].num=code.size();
-    load_continue_break(code.size()-1, code.size());
-}
-
-void codegen::for_gen(const ast& node) {
-    expr_gen(node[0]);
-    usize jmp_place=code.size();
-    if (node[1].type()==ast_null) {
-        gen(op_pnum, num_table[1], node[1].line());
-    } else {
-        calc_gen(node[1]);
-    }
-    usize label_exit=code.size();
-    gen(op_jf, 0, node[1].line());
-
-    block_gen(node[3]);
-    usize continue_place=code.size();
-    expr_gen(node[2]);
-    gen(op_jmp, jmp_place, node[2].line());
-    code[label_exit].num=code.size();
-
-    load_continue_break(continue_place, code.size());
-}
-
-void codegen::expr_gen(const ast& node) {
-    switch(node.type()) {
-        case ast_null:break;
-        case ast_def:def_gen(node);break;
-        case ast_multi_assign:multi_assign_gen(node);break;
-        case ast_addeq:case ast_subeq:
-        case ast_multeq:case ast_diveq:case ast_lnkeq:
-        case ast_btandeq:case ast_btoreq:case ast_btxoreq:
-            calc_gen(node);
-            if (op_addeq<=code.back().op && code.back().op<=op_btxoreq) {
-                code.back().num=1;
-            } else if (op_addeqc<=code.back().op && code.back().op<=op_lnkeqc) {
-                code.back().op=code.back().op-op_addeqc+op_addecp;
-            } else {
-                gen(op_pop, 0, node.line());
-            }
-            break;
-        case ast_nil:case ast_num:case ast_str:case ast_bool:break;
-        case ast_vec:case ast_hash:case ast_func:case ast_call:
-        case ast_neg:case ast_lnot:case ast_bnot:
-        case ast_bitor:case ast_bitxor:case ast_bitand:
-        case ast_add:case ast_sub:case ast_mult:case ast_div:case ast_link:
-        case ast_cmpeq:case ast_neq:
-        case ast_leq:case ast_less:
-        case ast_geq:case ast_grt:
-        case ast_or:case ast_and:
-        case ast_trino:
-            calc_gen(node);
-            gen(op_pop, 0, node.line());
-            break;
-        case ast_equal:
-            if (node[0].type()==ast_id) {
-                calc_gen(node[1]);
-                mcall_id(node[0]);
-                // only the first mcall_id can use load
-                if (code.back().op==op_mcalll) {
-                    code.back().op=op_loadl;
-                } else if (code.back().op==op_mupval) {
-                    code.back().op=op_loadu;
-                } else {
-                    code.back().op=op_loadg;
-                }
-            } else {
-                calc_gen(node);
-                if (code.back().op==op_meq) {
-                    code.back().num=1;
-                } else {
-                    gen(op_pop, 0, node.line());
-                }
-            }
-            break;
-    }
-}
-
-void codegen::forindex_gen(const ast& node) {
-    calc_gen(node[1]);
-    gen(op_cnt, 0, node[1].line());
-    usize ptr=code.size();
-    gen(op_findex, 0, node.line());
-    if (node[0].type()==ast_iter) { // define a new iterator
-        const string& str=node[0][0].str();
-        local.empty()?
-            gen(op_loadg, global_find(str), node[0][0].line()):
-            gen(op_loadl, local_find(str), node[0][0].line());
-    } else { // use exist variable as the iterator
-        mcall(node[0]);
-        if (code.back().op==op_mcallg) {
-            code.back().op=op_loadg;
-        } else if (code.back().op==op_mcalll) {
-            code.back().op=op_loadl;
-        } else if (code.back().op==op_mupval) {
-            code.back().op=op_loadu;
-        } else {
-            gen(op_meq, 1, node[0].line());
-        }
-    }
-    ++in_iterloop.top();
-    block_gen(node[2]);
-    --in_iterloop.top();
-    gen(op_jmp, ptr, node.line());
-    code[ptr].num=code.size();
-    load_continue_break(code.size()-1, code.size());
-    gen(op_pop, 0, node[1].line());// pop vector
-    gen(op_pop, 0, node.line());// pop iterator
-}
-
-void codegen::foreach_gen(const ast& node) {
-    calc_gen(node[1]);
-    gen(op_cnt, 0, node.line());
-    usize ptr=code.size();
-    gen(op_feach, 0, node.line());
-    if (node[0].type()==ast_iter) { // define a new iterator
-        const string& str=node[0][0].str();
-        local.empty()?
-            gen(op_loadg, global_find(str), node[0][0].line()):
-            gen(op_loadl, local_find(str), node[0][0].line());
-    } else { // use exist variable as the iterator
-        mcall(node[0]);
-        if (code.back().op==op_mcallg) {
-            code.back().op=op_loadg;
-        } else if (code.back().op==op_mcalll) {
-            code.back().op=op_loadl;
-        } else if (code.back().op==op_mupval) {
-            code.back().op=op_loadu;
-        } else {
-            gen(op_meq, 1, node[0].line());
-        }
-    }
-    ++in_iterloop.top();
-    block_gen(node[2]);
-    --in_iterloop.top();
-    gen(op_jmp, ptr, node.line());
-    code[ptr].num=code.size();
-    load_continue_break(code.size()-1, code.size());
-    gen(op_pop, 0, node[1].line());// pop vector
-    gen(op_pop, 0, node.line());// pop iterator
-}
-
-void codegen::or_gen(const ast& node) {
-    calc_gen(node[0]);
-    usize l1=code.size();
-    gen(op_jt, 0, node[0].line());
-
-    gen(op_pop, 0, node[0].line());
-    calc_gen(node[1]);
-    usize l2=code.size();
-    gen(op_jt, 0, node[1].line());
-
-    gen(op_pop, 0, node[1].line());
-    gen(op_pnil, 0, node[1].line());
-
-    code[l1].num=code[l2].num=code.size();
-}
-
-void codegen::and_gen(const ast& node) {
-    calc_gen(node[0]);
-    gen(op_jt, code.size()+2, node[0].line());
-
-    usize lfalse=code.size();
-    gen(op_jmp, 0, node[0].line());
-    gen(op_pop, 0, node[1].line());// jt jumps here
-
-    calc_gen(node[1]);
-    gen(op_jt, code.size()+3, node[1].line());
-
-    code[lfalse].num=code.size();
-    gen(op_pop, 0, node[1].line());
-    gen(op_pnil, 0, node[1].line());
-    // jt jumps here
-}
-
-void codegen::trino_gen(const ast& node) {
-    calc_gen(node[0]);
-    usize lfalse=code.size();
-    gen(op_jf, 0, node[0].line());
-    calc_gen(node[1]);
-    usize lexit=code.size();
-    gen(op_jmp, 0, node[1].line());
-    code[lfalse].num=code.size();
-    calc_gen(node[2]);
-    code[lexit].num=code.size();
-}
-
-void codegen::calc_gen(const ast& node) {
-    switch(node.type()) {
-        case ast_nil:  gen(op_pnil,0,node.line());break;
-        case ast_num:  num_gen(node);  break;
-        case ast_str:  str_gen(node);  break;
-        case ast_id:   call_id(node);  break;
-        case ast_bool: bool_gen(node); break;
-        case ast_vec:  vec_gen(node);  break;
-        case ast_hash: hash_gen(node); break;
-        case ast_func: func_gen(node); break;
-        case ast_call: call_gen(node); break;
-        case ast_equal:
-            calc_gen(node[1]);
-            mcall(node[0]);
-            gen(op_meq, 0, node.line());
-            break;
-        // ast_addeq(22)~ast_lnkeq(26) op_addeq(23)~op_lnkeq(27)
-        case ast_addeq:case ast_subeq:case ast_multeq:case ast_diveq:
-            if (node[1].type()!=ast_num) {
-                calc_gen(node[1]);
-            }
-            mcall(node[0]);
-            if (node[1].type()!=ast_num) {
-                gen(node.type()-ast_addeq+op_addeq, 0, node.line());
-            } else {
-                regist_num(node[1].num());
-                gen(node.type()-ast_addeq+op_addeqc, num_table[node[1].num()], node.line());
-            }
-            break;
-        case ast_lnkeq:
-            if (node[1].type()!=ast_str) {
-                calc_gen(node[1]);
-            } else {
-                regist_str(node[1].str());
-            }
-            mcall(node[0]);
-            if (node[1].type()!=ast_str) {
-                gen(op_lnkeq, 0, node.line());
-            } else {
-                gen(op_lnkeqc, str_table[node[1].str()], node.line());
-            }
-            break;
-        case ast_btandeq:case ast_btoreq:case ast_btxoreq:
-            calc_gen(node[1]);
-            mcall(node[0]);
-            gen(node.type()-ast_btandeq+op_btandeq, 0, node.line());
-            break;
-        case ast_or:or_gen(node);break;
-        case ast_and:and_gen(node);break;
-        // ast_add(33)~ast_link(37) op_add(18)~op_lnk(22)
-        case ast_add:case ast_sub:case ast_mult:case ast_div:
-            calc_gen(node[0]);
-            if (node[1].type()!=ast_num) {
-                calc_gen(node[1]);
-                gen(node.type()-ast_add+op_add, 0, node.line());
-            } else {
-                regist_num(node[1].num());
-                gen(node.type()-ast_add+op_addc, num_table[node[1].num()], node.line());
-            }
-            break;
-        case ast_link:
-            calc_gen(node[0]);
-            if (node[1].type()!=ast_str) {
-                calc_gen(node[1]);
-                gen(op_lnk, 0, node.line());
-            } else {
-                regist_str(node[1].str());
-                gen(op_lnkc, str_table[node[1].str()], node.line());
-            }
-            break;
-        // ast_cmpeq(27)~ast_geq(32) op_eq(29)~op_geq(34)
-        case ast_cmpeq:case ast_neq:
-            calc_gen(node[0]);
-            calc_gen(node[1]);
-            gen(node.type()-ast_cmpeq+op_eq, 0, node.line());
-            break;
-        case ast_less:case ast_leq:case ast_grt:case ast_geq:
-            calc_gen(node[0]);
-            if (node[1].type()!=ast_num) {
-                calc_gen(node[1]);
-                gen(node.type()-ast_less+op_less, 0, node.line());
-            } else {
-                regist_num(node[1].num());
-                gen(node.type()-ast_less+op_lessc, num_table[node[1].num()], node.line());
-            }
-            break;
-        case ast_trino:trino_gen(node);break;
-        case ast_neg:
-            calc_gen(node[0]);
-            gen(op_usub, 0, node.line());
-            break;
-        case ast_lnot:
-            calc_gen(node[0]);
-            gen(op_lnot, 0, node.line());
-            break;
-        case ast_bnot:
-            calc_gen(node[0]);
-            gen(op_bnot, 0, node.line());
-            break;
-        case ast_bitor:
-            calc_gen(node[0]);
-            calc_gen(node[1]);
-            gen(op_btor, 0, node.line());
-            break;
-        case ast_bitxor:
-            calc_gen(node[0]);
-            calc_gen(node[1]);
-            gen(op_btxor, 0, node.line());
-            break;
-        case ast_bitand:
-            calc_gen(node[0]);
-            calc_gen(node[1]);
-            gen(op_btand, 0, node.line());
-            break;
-        case ast_def:
-            single_def(node);
-            call_id(node[0]);
-            break;
-    }
-}
-
-void codegen::block_gen(const ast& node) {
-    for(auto& tmp:node.child()) {
-        switch(tmp.type()) {
-            case ast_null:break;
-            case ast_id:check_id_exist(tmp);break;
-            case ast_nil:case ast_num:case ast_str:case ast_bool:break;
-            case ast_file:fileindex=tmp.num();break; // special node type in main block
-            case ast_cond:cond_gen(tmp);break;
-            case ast_continue:
-                continue_ptr.front().push_back(code.size());
-                gen(op_jmp, 0, tmp.line());
-                break;
-            case ast_break:
-                break_ptr.front().push_back(code.size());
-                gen(op_jmp, 0, tmp.line());
-                break;
-            case ast_while:
-            case ast_for:
-            case ast_forindex:
-            case ast_foreach:loop_gen(tmp);break;
-            case ast_equal:
-            case ast_addeq:case ast_subeq:
-            case ast_multeq:case ast_diveq:case ast_lnkeq:
-            case ast_btandeq:case ast_btoreq:case ast_btxoreq:
-            case ast_vec:case ast_hash:case ast_func:case ast_call:
-            case ast_neg:case ast_lnot:case ast_bnot:
-            case ast_bitor:case ast_bitxor:case ast_bitand:
-            case ast_add:case ast_sub:case ast_mult:case ast_div:case ast_link:
-            case ast_cmpeq:case ast_neq:
-            case ast_leq:case ast_less:
-            case ast_geq:case ast_grt:
-            case ast_or:
-            case ast_and:
-            case ast_trino:
-            case ast_def:
-            case ast_multi_assign:expr_gen(tmp);break;
-            case ast_ret:ret_gen(tmp);break;
-        }
-    }
-}
-
-void codegen::ret_gen(const ast& node) {
-    for(u32 i=0;i<in_iterloop.top();++i) {
-        gen(op_pop, 0, node.line());
-        gen(op_pop, 0, node.line());
-    }
-    if (node.size()) {
-        calc_gen(node[0]);
-    } else {
-        gen(op_pnil, 0, node.line());
-    }
-    gen(op_ret, 0, node.line());
-}
-
-const error& codegen::compile(const parse& parse, const linker& import) {
-    fileindex=0;
-    file=import.filelist().data();
-    in_iterloop.push(0);
-    find_symbol(parse.tree()); // search symbols first
-    gen(op_intg, global.size(), 0);
-    block_gen(parse.tree()); // generate main block
-    gen(op_exit, 0, 0);
-
-    // size out of bound check
-    if (num_res.size()>0xffffff) {
-        err.load(file[0]); // load main execute file
-        err.err("code", "too many constant numbers: "+std::to_string(num_res.size()));
-    }
-    if (str_res.size()>0xffffff) {
-        err.load(file[0]); // load main execute file
-        err.err("code", "too many constant strings: "+std::to_string(str_res.size()));
-    }
-    if (global.size()>=STACK_DEPTH) {
-        err.load(file[0]); // load main execute file
-        err.err("code", "too many global variants: "+std::to_string(global.size()));
-    }
-    if (code.size()>0xffffff) {
-        err.load(file[0]); // load main execute file
-        err.err("code", "bytecode size overflow: "+std::to_string(code.size()));
-    }
-    return err;
-}
-
-void codegen::print() {
-    // func end stack, reserved for code print
-    std::stack<u32> fbstk;
-    std::stack<u32> festk;
-
-    // print const numbers
-    for(auto& num:num_res) {
-        std::cout<<"  .number "<<num<<"\n";
-    }
-
-    // print const strings
-    for(auto& str:str_res) {
-        std::cout<<"  .symbol \""<<rawstr(str)<<"\"\n";
-    }
-
-    // print code
-    std::cout<<"\n";
-    codestream::set(num_res.data(), str_res.data());
-    for(u32 i=0;i<code.size();++i) {
-        // print opcode index, opcode name, opcode immediate number
-        const opcode& c=code[i];
-        if (!festk.empty() && i==festk.top()) {
-            std::cout<<std::hex<<"<0x"<<fbstk.top()<<std::dec<<">;\n";
-            // avoid two empty lines
-            if (c.op!=op_newf) {
-                std::cout<<"\n";
-            }
-            fbstk.pop();
-            festk.pop();
-        }
-
-        // get function begin index and end index
-        if (c.op==op_newf) {
-            std::cout<<std::hex<<"\nfunc <0x"<<i<<std::dec<<">:\n";
-            for(u32 j=i;j<code.size();++j) {
-                if (code[j].op==op_jmp) {
-                    fbstk.push(i);
-                    festk.push(code[j].num);
-                    break;
-                }
-            }
-        }
-
-        // output bytecode
-        std::cout<<"  "<<codestream(c,i)<<"\n";
-    }
-}
diff --git a/nasal_dbg.h b/nasal_dbg.h
deleted file mode 100644
index a10fc42..0000000
--- a/nasal_dbg.h
+++ /dev/null
@@ -1,321 +0,0 @@
-#pragma once
-
-#include "nasal_import.h"
-#include "nasal_err.h"
-#include "nasal_opcode.h"
-#include "nasal_vm.h"
-
-#include <cstring>
-#include <algorithm>
-#include <unordered_map>
-
-class dbg:public vm {
-private:
-    enum class dbg_cmd {
-        cmd_error,
-        cmd_help,
-        cmd_backtrace,
-        cmd_continue,
-        cmd_list_file,
-        cmd_global,
-        cmd_local,
-        cmd_upval,
-        cmd_register,
-        cmd_show_all,
-        cmd_next,
-        cmd_break_point,
-        cmd_exit
-    };
-
-private:
-    const std::unordered_map<string, dbg_cmd> command_table = {
-        {"h", dbg_cmd::cmd_help},
-        {"help", dbg_cmd::cmd_help},
-        {"bt", dbg_cmd::cmd_backtrace},
-        {"backtrace", dbg_cmd::cmd_backtrace},
-        {"c", dbg_cmd::cmd_continue},
-        {"continue", dbg_cmd::cmd_continue},
-        {"f", dbg_cmd::cmd_list_file},
-        {"file", dbg_cmd::cmd_list_file},
-        {"g", dbg_cmd::cmd_global},
-        {"global", dbg_cmd::cmd_global},
-        {"l", dbg_cmd::cmd_local},
-        {"local", dbg_cmd::cmd_local},
-        {"u", dbg_cmd::cmd_upval},
-        {"upval", dbg_cmd::cmd_upval},
-        {"r", dbg_cmd::cmd_register},
-        {"register", dbg_cmd::cmd_register},
-        {"a", dbg_cmd::cmd_show_all},
-        {"all", dbg_cmd::cmd_show_all},
-        {"n", dbg_cmd::cmd_next},
-        {"next", dbg_cmd::cmd_next},
-        {"bk", dbg_cmd::cmd_break_point},
-        {"break", dbg_cmd::cmd_break_point},
-        {"q", dbg_cmd::cmd_exit},
-        {"exit", dbg_cmd::cmd_exit}
-    };
-    dbg_cmd get_cmd_type(const string& cmd) const {
-        return command_table.count(cmd)?
-            command_table.at(cmd):dbg_cmd::cmd_error;
-    }
-
-private:
-    bool  next;
-    usize fsize;
-    u16   bk_fidx;
-    u32   bk_line;
-    error& src;
-
-    std::vector<string> parse(const string&);
-    u16 file_index(const string&) const;
-    void err();
-    void help();
-    void list_file() const;
-    void call_sort(const u64*) const;
-    void step_info();
-    void interact();
-public:
-    dbg(error& err):
-        next(false), fsize(0),
-        bk_fidx(0), bk_line(0),
-        src(err) {}
-    void run(
-        const codegen&,
-        const linker&,
-        const std::vector<string>&
-    );
-};
-
-std::vector<string> dbg::parse(const string& cmd) {
-    std::vector<string> res;
-    usize last=0;
-    usize pos=cmd.find(" ", 0);
-    while(pos!=string::npos) {
-        if (pos>last) {
-            res.push_back(cmd.substr(last, pos-last));
-        }
-        last=pos+1;
-        pos=cmd.find(" ", last);
-    }
-    if (last<cmd.length()) {
-        res.push_back(cmd.substr(last));
-    }
-    return res;
-}
-
-u16 dbg::file_index(const string& filename) const {
-    for(u16 i=0;i<fsize;++i) {
-        if (filename==files[i]) {
-            return i;
-        }
-    }
-    return 65535;
-}
-
-void dbg::err() {
-    std::cerr
-    <<"incorrect command\n"
-    <<"input \'h\' to get help\n";
-}
-
-void dbg::help() {
-    std::clog
-    <<"<option>\n"
-    <<"  h,   help      | get help\n"
-    <<"  bt,  backtrace | get function call trace\n"
-    <<"  c,   continue  | run program until break point or exit\n"
-    <<"  f,   file      | see all the compiled files\n"
-    <<"  g,   global    | see global values\n"
-    <<"  l,   local     | see local values\n"
-    <<"  u,   upval     | see upvalue\n"
-    <<"  r,   register  | show vm register detail\n"
-    <<"  a,   all       | show global,local and upvalue\n"
-    <<"  n,   next      | execute next bytecode\n"
-    <<"  q,   exit      | exit debugger\n"
-    <<"<option> <filename> <line>\n"
-    <<"  bk,  break     | set break point\n";
-}
-
-void dbg::list_file() const {
-    for(usize i=0; i<fsize; ++i) {
-        std::clog<<"["<<i<<"] "<<files[i]<<"\n";
-    }
-}
-
-void dbg::call_sort(const u64* arr) const {
-    typedef std::pair<u32,u64> op;
-    std::vector<op> opcall;
-    u64 total=0;
-    for(u32 i=0;i<op_ret+1;++i) {
-        total+=arr[i];
-        opcall.push_back({i, arr[i]});
-    }
-    std::sort(opcall.begin(), opcall.end(),
-        [](const op& a, const op& b) {return a.second>b.second;}
-    );
-    std::clog<<"\noperands call info (<1% ignored)\n";
-    for(auto& i:opcall) {
-        u64 rate=i.second*100/total;
-        if (!rate) {
-            break;
-        }
-        std::clog<<" "<<opname[i.first]<<" : "<<i.second<<" ("<<rate<<"%)\n";
-    }
-    std::clog<<" total  : "<<total<<'\n';
-}
-
-void dbg::step_info() {
-    u32 line=bytecode[ctx.pc].line==0?0:bytecode[ctx.pc].line-1;
-    u32 begin=(line>>3)==0?0:((line>>3)<<3);
-    u32 end=(1+(line>>3))<<3;
-    src.load(files[bytecode[ctx.pc].fidx]);
-    std::clog<<"\nsource code:\n";
-    for(u32 i=begin;i<end && i<src.size();++i) {
-        std::clog<<(i==line?back_white:reset)<<(i==line?"--> ":"    ")<<src[i]<<reset<<"\n";
-    }
-
-    begin=(ctx.pc>>3)==0?0:((ctx.pc>>3)<<3);
-    end=(1+(ctx.pc>>3))<<3;
-    codestream::set(cnum, cstr, files);
-    std::clog<<"next bytecode:\n";
-    for(u32 i=begin;i<end && bytecode[i].op!=op_exit;++i) {
-        std::clog
-        <<(i==ctx.pc?back_white:reset)
-        <<(i==ctx.pc?"--> ":"    ")
-        <<codestream(bytecode[i], i)
-        <<reset<<"\n";
-    }
-    stackinfo(10);
-}
-
-void dbg::interact() {
-    // special operand, end execution
-    if (bytecode[ctx.pc].op==op_exit) {
-        return;
-    }
-    
-    if ((bytecode[ctx.pc].fidx!=bk_fidx ||
-        bytecode[ctx.pc].line!=bk_line) && // break point
-        !next) {// next step
-        return;
-    }
-
-    next=false;
-    string cmd;
-    step_info();
-    while(true) {
-        std::clog<<">> ";
-        std::getline(std::cin, cmd);
-        auto res=parse(cmd);
-        if (res.size()==0) {
-            step_info();
-        } else if (res.size()==1) {
-            switch(get_cmd_type(res[0])) {
-                case dbg_cmd::cmd_help: help(); break;
-                case dbg_cmd::cmd_backtrace: traceback(); break;
-                case dbg_cmd::cmd_continue: return;
-                case dbg_cmd::cmd_list_file: list_file(); break;
-                case dbg_cmd::cmd_global: gstate(); break;
-                case dbg_cmd::cmd_local: lstate(); break;
-                case dbg_cmd::cmd_upval: ustate(); break;
-                case dbg_cmd::cmd_register: reginfo(); break;
-                case dbg_cmd::cmd_show_all: detail(); break;
-                case dbg_cmd::cmd_next: next=true; return;
-                case dbg_cmd::cmd_exit: std::exit(0);
-                default: err(); break;
-            }
-        } else if (res.size()==3 &&
-            get_cmd_type(res[0])==dbg_cmd::cmd_break_point) {
-            bk_fidx=file_index(res[1]);
-            if (bk_fidx==65535) {
-                std::clog<<"cannot find file named `"<<res[1]<<"`\n";
-                continue;
-            }
-            i32 tmp=atoi(res[2].c_str());
-            if (tmp<=0) {
-                std::clog<<"incorrect line number `"<<res[2]<<"`\n";
-            } else {
-                bk_line=tmp;
-            }
-        } else {
-            err();
-        }
-    }
-}
-
-void dbg::run(
-    const codegen& gen,
-    const linker& linker,
-    const std::vector<string>& argv) {
-    verbose=true;
-    fsize=linker.filelist().size();
-    init(gen.strs(), gen.nums(), gen.codes(), linker.filelist(), argv);
-    u64 count[op_ret+1]={0};
-    typedef void (dbg::*nafunc)();
-    const nafunc oprs[]={
-        nullptr,        &dbg::o_intg,
-        &dbg::o_intl,   &dbg::o_loadg,
-        &dbg::o_loadl,  &dbg::o_loadu,
-        &dbg::o_pnum,   &dbg::o_pnil,
-        &dbg::o_pstr,   &dbg::o_newv,
-        &dbg::o_newh,   &dbg::o_newf,
-        &dbg::o_happ,   &dbg::o_para,
-        &dbg::o_deft,   &dbg::o_dyn,
-        &dbg::o_lnot,   &dbg::o_usub,
-        &dbg::o_bnot,   &dbg::o_btor,
-        &dbg::o_btxor,  &dbg::o_btand,
-        &dbg::o_add,    &dbg::o_sub,
-        &dbg::o_mul,    &dbg::o_div,
-        &dbg::o_lnk,    &dbg::o_addc,
-        &dbg::o_subc,   &dbg::o_mulc,
-        &dbg::o_divc,   &dbg::o_lnkc,
-        &dbg::o_addeq,  &dbg::o_subeq,
-        &dbg::o_muleq,  &dbg::o_diveq,
-        &dbg::o_lnkeq,  &dbg::o_bandeq,
-        &dbg::o_boreq,  &dbg::o_bxoreq,
-        &dbg::o_addeqc, &dbg::o_subeqc,
-        &dbg::o_muleqc, &dbg::o_diveqc,
-        &dbg::o_lnkeqc, &dbg::o_addecp,
-        &dbg::o_subecp, &dbg::o_mulecp,
-        &dbg::o_divecp, &dbg::o_lnkecp,
-        &dbg::o_meq,    &dbg::o_eq,
-        &dbg::o_neq,    &dbg::o_less,
-        &dbg::o_leq,    &dbg::o_grt,
-        &dbg::o_geq,    &dbg::o_lessc,
-        &dbg::o_leqc,   &dbg::o_grtc,
-        &dbg::o_geqc,   &dbg::o_pop,
-        &dbg::o_jmp,    &dbg::o_jt,
-        &dbg::o_jf,     &dbg::o_cnt,
-        &dbg::o_findex, &dbg::o_feach,
-        &dbg::o_callg,  &dbg::o_calll,
-        &dbg::o_upval,  &dbg::o_callv,
-        &dbg::o_callvi, &dbg::o_callh,
-        &dbg::o_callfv, &dbg::o_callfh,
-        &dbg::o_callb,  &dbg::o_slcbeg,
-        &dbg::o_slcend, &dbg::o_slc,
-        &dbg::o_slc2,   &dbg::o_mcallg,
-        &dbg::o_mcalll, &dbg::o_mupval,
-        &dbg::o_mcallv, &dbg::o_mcallh,
-        &dbg::o_ret
-    };
-    std::vector<u32> code;
-    for(auto& i:gen.codes()) {
-        code.push_back(i.op);
-        imm.push_back(i.num);
-    }
-    while(oprs[code[ctx.pc]]) {
-        interact();
-        ++count[code[ctx.pc]];
-        (this->*oprs[code[ctx.pc]])();
-        if (ctx.top>=ctx.canary) {
-            die("stack overflow");
-        }
-        ++ctx.pc;
-    }
-
-    call_sort(count);
-    ngc.info();
-    ngc.clear();
-    imm.clear();
-    return;
-}
diff --git a/nasal_err.h b/nasal_err.h
deleted file mode 100644
index c2f4545..0000000
--- a/nasal_err.h
+++ /dev/null
@@ -1,228 +0,0 @@
-#pragma once
-
-#include <iostream>
-#include <fstream>
-#include <sstream> // MSVC need this to use std::getline
-#include <cstring>
-#include <vector>
-
-#include "nasal.h"
-
-struct span {
-    u32 begin_line;
-    u32 begin_column;
-    u32 end_line;
-    u32 end_column;
-    string file;
-};
-
-#ifdef _WIN32
-#include <windows.h> // use SetConsoleTextAttribute
-struct for_reset {
-    CONSOLE_SCREEN_BUFFER_INFO scr;
-    for_reset() {
-        GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &scr);
-    }
-} reset_ter_color;
-#endif
-
-std::ostream& back_white(std::ostream& s) {
-#ifdef _WIN32
-    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0xf0);
-#else
-    s<<"\033[7m";
-#endif
-    return s;
-}
-
-std::ostream& red(std::ostream& s) {
-#ifdef _WIN32
-    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0c);
-#else
-    s<<"\033[91;1m";
-#endif
-    return s;
-}
-
-std::ostream& cyan(std::ostream& s) {
-#ifdef _WIN32
-    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x03);
-#else
-    s<<"\033[36;1m";
-#endif
-    return s;
-}
-
-std::ostream& orange(std::ostream& s) {
-#ifdef _WIN32
-    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0e);
-#else
-    s<<"\033[93;1m";
-#endif
-    return s;
-}
-
-std::ostream& white(std::ostream& s) {
-#ifdef _WIN32
-    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0f);
-#else
-    s<<"\033[0m\033[1m";
-#endif
-    return s;
-}
-
-std::ostream& reset(std::ostream& s) {
-#ifdef _WIN32
-    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), reset_ter_color.scr.wAttributes);
-#else
-    s<<"\033[0m";
-#endif
-    return s;
-}
-
-class flstream {
-protected:
-    string file;
-    std::vector<string> res;
-public:
-    flstream():file("") {}
-    void load(const string&);
-    const string& operator[](usize n) const {return res[n];}
-    const string& name() const {return file;}
-    usize size() const {return res.size();}
-};
-
-class error:public flstream {
-private:
-    u32 cnt; // counter for errors
-
-    string identation(usize len) {
-        return string(len,' ');
-    }
-    string leftpad(u32 num, usize len) {
-        string tmp=std::to_string(num);
-        while(tmp.length()<len) {
-            tmp=" "+tmp;
-        }
-        return tmp;
-    }
-public:
-    error():cnt(0) {}
-    void fatal(const string&, const string&);
-    void err(const string&, const string&);
-    void err(const string&, const span&, const string&);
-
-    void chkerr() const {
-        if (cnt) {
-            std::exit(1);
-        }
-    }
-};
-
-
-void flstream::load(const string& f) {
-    if (file==f) { // don't need to load a loaded file
-        return;
-    } else {
-        file=f;
-    }
-
-    res.clear();
-    std::ifstream in(f, std::ios::binary);
-    if (in.fail()) {
-        std::cerr<<red<<"src: "<<reset<<"cannot open <"<<f<<">\n";
-        std::exit(1);
-    }
-    
-    while(!in.eof()) {
-        string line;
-        std::getline(in, line);
-        res.push_back(line);
-    }
-}
-
-void error::fatal(const string& stage, const string& info) {
-    std::cerr<<red<<stage<<": "<<white<<info<<reset<<"\n";
-    if (file.length()) {
-        std::cerr<<cyan<<" --> "<<red<<file<<reset<<"\n\n";
-    } else {
-        std::cerr<<reset<<"\n";
-    }
-    std::exit(1);
-}
-
-void error::err(const string& stage, const string& info) {
-    ++cnt;
-    std::cerr<<red<<stage<<": "<<white<<info<<reset<<"\n";
-    if (file.length()) {
-        std::cerr<<cyan<<" --> "<<red<<file<<reset<<"\n\n";
-    } else {
-        std::cerr<<reset<<"\n";
-    }
-}
-
-void error::err(const string& stage, const span& loc, const string& info) {
-    // load error occurred file into string lines
-    load(loc.file);
-
-    ++cnt;
-
-    std::cerr
-    <<red<<stage<<": "<<white<<info<<reset<<"\n"<<cyan<<"  --> "
-    <<red<<loc.file<<":"<<loc.begin_line<<":"<<loc.begin_column+1<<reset<<"\n";
-
-    const usize maxlen=std::to_string(loc.end_line).length();
-    const string iden=identation(maxlen);
-
-    for(u32 line=loc.begin_line; line<=loc.end_line; ++line) {
-        if (!line) {
-            continue;
-        }
-
-        if (loc.begin_line<line && line<loc.end_line) {
-            if (line==loc.begin_line+1) {
-                std::cerr<<cyan<<iden<<" | "<<reset<<"...\n"<<cyan<<iden<<" | "<<reset<<"\n";
-            }
-            continue;
-        }
-
-        // if this line has nothing, skip
-        if (!res[line-1].length() && line!=loc.end_line) {
-            continue;
-        }
-
-        const string& code=res[line-1];
-        std::cerr<<cyan<<leftpad(line, maxlen)<<" | "<<reset<<code<<"\n";
-        // output underline
-        std::cerr<<cyan<<iden<<" | "<<reset;
-        if (loc.begin_line==loc.end_line) {
-            for(u32 i=0; i<loc.begin_column; ++i) {
-                std::cerr<<char(" \t"[code[i]=='\t']);
-            }
-            for(u32 i=loc.begin_column ;i<loc.end_column; ++i) {
-                std::cerr<<red<<(code[i]=='\t'?"^^^^":"^")<<reset;
-            }
-        } else if (line==loc.begin_line) {
-            for(u32 i=0; i<loc.begin_column; ++i) {
-                std::cerr<<char(" \t"[code[i]=='\t']);
-            }
-            for(u32 i=loc.begin_column; i<code.size(); ++i) {
-                std::cerr<<red<<(code[i]=='\t'?"^^^^":"^")<<reset;
-            }
-        } else if (loc.begin_line<line && line<loc.end_line) {
-            for(u32 i=0; i<code.size(); ++i) {
-                std::cerr<<red<<(code[i]=='\t'?"^^^^":"^");
-            }
-        } else {
-            for(u32 i=0; i<loc.end_column; ++i) {
-                std::cerr<<red<<(code[i]=='\t'?"^^^^":"^");
-            }
-        }
-        if (line==loc.end_line) {
-            std::cerr<<reset;
-        } else {
-            std::cerr<<reset<<"\n";
-        }
-    }
-    std::cerr<<"\n\n";
-}
\ No newline at end of file
diff --git a/nasal_gc.h b/nasal_gc.h
deleted file mode 100644
index d66bf25..0000000
--- a/nasal_gc.h
+++ /dev/null
@@ -1,928 +0,0 @@
-#pragma once
-
-// avoid MSVC warnings
-#ifdef _MSC_VER
-#pragma warning (disable:4244)
-#pragma warning (disable:4267)
-#pragma warning (disable:4102)
-#endif
-
-#ifndef _MSC_VER
-#include <unistd.h>
-#include <dirent.h>
-#else
-#include <io.h>
-#include <direct.h>
-#endif
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <dlfcn.h>
-#endif
-
-#include <iomanip>
-#include <vector>
-#include <unordered_map>
-#include <chrono>
-#include <algorithm>
-
-#include "nasal.h"
-#include "nasal_err.h"
-
-enum vm_type:u8 {
-    /* none-gc object */
-    vm_none=0,
-    vm_cnt,
-    vm_addr,
-    vm_ret,
-    vm_nil,
-    vm_num,
-    /* gc object */
-    vm_str,
-    vm_vec,
-    vm_hash,
-    vm_func,
-    vm_upval,
-    vm_obj,
-    vm_co
-};
-
-const u32 gc_type_size=vm_co-vm_str+1;
-
-enum class coroutine_status:u32 {
-    suspended,
-    running,
-    dead
-};
-
-enum class gc_status:u8 {
-    uncollected=0,   
-    collected,
-    found
-};
-
-struct nas_vec;   // vector
-struct nas_hash;  // hashmap(dict)
-struct nas_func;  // function(lambda)
-struct nas_upval; // upvalue
-struct nas_ghost; // objects
-struct nas_co;    // coroutine
-struct nas_val;   // nas_val includes gc-managed types
-
-struct var {
-public:
-    u8 type;
-    union {
-        u32 ret;
-        i64 cnt;
-        f64 num;
-        var* addr;
-        nas_val* gcobj;
-    } val;
-
-private:
-    var(u8 t, u32 pc) {type=t;val.ret=pc;}
-    var(u8 t, i64 ct) {type=t;val.cnt=ct;}
-    var(u8 t, f64 n) {type=t;val.num=n;}
-    var(u8 t, var* p) {type=t;val.addr=p;}
-    var(u8 t, nas_val* p) {type=t;val.gcobj=p;}
-
-public:
-    var() = default;
-    var(const var&) = default;
-    bool operator==(const var& nr) const {return type==nr.type && val.gcobj==nr.val.gcobj;}
-    bool operator!=(const var& nr) const {return type!=nr.type || val.gcobj!=nr.val.gcobj;}
-    friend std::ostream& operator<<(std::ostream&, var&);
-
-    // number and string can be translated to each other
-    f64 tonum();
-    string tostr();
-    bool objchk(usize);
-
-    // create new var object
-    static var none();
-    static var nil();
-    static var ret(u32);
-    static var cnt(i64);
-    static var num(f64);
-    static var gcobj(nas_val*);
-    static var addr(var*);
-
-    // get content
-    var*       addr();
-    u32        ret ();
-    i64&       cnt ();
-    f64        num ();
-    string&    str ();
-    nas_vec&   vec ();
-    nas_hash&  hash();
-    nas_func&  func();
-    nas_upval& upval();
-    nas_ghost& obj ();
-    nas_co&    co  ();
-};
-
-struct nas_vec {
-    std::vector<var> elems;
-
-    // mark if this is printed, avoid stackoverflow
-    bool printed;
-
-    nas_vec():printed(false) {}
-    usize size() const {return elems.size();}
-    var get_val(const i32);
-    var* get_mem(const i32);
-};
-
-struct nas_hash {
-    std::unordered_map<string,var> elems;
-
-    // mark if this is printed, avoid stackoverflow
-    bool printed;
-
-    nas_hash():printed(false) {}
-    usize size() const {return elems.size();}
-    var get_val(const string&);
-    var* get_mem(const string&);
-};
-
-struct nas_func {
-    i32 dpara; // dynamic parameter name index in hash.
-    u32 entry; // pc will set to entry-1 to call this function
-    u32 psize; // used to load default parameters to a new function
-    u32 lsize; // used to expand memory space for local values on stack
-    std::vector<var> local; // local scope with default value(var)
-    std::vector<var> upval; // closure
-    std::unordered_map<u32,u32> keys; // parameter table, u32 begins from 1
-
-    nas_func(): dpara(-1), entry(0), psize(0), lsize(0) {}
-    void clear();
-};
-
-struct nas_upval {
-public:
-    /* on stack, use these variables */
-    bool onstk;
-    u32 size;
-    var* stk;
-
-    /* not on stack, use this */
-    std::vector<var> elems;
-
-public:
-    nas_upval(): onstk(true), size(0), stk(nullptr) {}
-
-    var& operator[](usize n) {
-        return onstk? stk[n]:elems[n];
-    }
-
-    void clear() {
-        onstk=true;
-        elems.clear();
-        size=0;
-    }
-};
-
-void filehandle_destructor(void* ptr) {
-    if ((FILE*)ptr==stdin) {
-        return;
-    }
-    fclose((FILE*)ptr);
-}
-
-void dir_entry_destructor(void* ptr) {
-#ifndef _MSC_VER
-    closedir((DIR*)ptr);
-#else
-    FindClose(ptr);
-#endif
-}
-
-void dylib_destructor(void* ptr) {
-#ifdef _WIN32
-    FreeLibrary((HMODULE)ptr);
-#else
-    dlclose(ptr);
-#endif
-}
-
-void func_addr_destructor(void* ptr) {}
-
-struct ghost_register_table {
-private:
-    using dtor=void (*)(void*);
-
-private:
-    std::unordered_map<string,usize> mapper;
-    std::vector<string> ghost_name;
-    std::vector<dtor> destructors;
-
-public:
-    // reserved ghost type only for native functions
-    usize ghost_file;
-    usize ghost_dir;
-    usize ghost_dylib;
-    usize ghost_faddr;
-
-public:
-    ghost_register_table() {
-        ghost_file=register_ghost_type("file", filehandle_destructor);
-        ghost_dir=register_ghost_type("dir", dir_entry_destructor);
-        ghost_dylib=register_ghost_type("dylib", dylib_destructor);
-        ghost_faddr=register_ghost_type("faddr", func_addr_destructor);
-    }
-
-    bool exists(const string& name) const {
-        return mapper.count(name);
-    }
-
-    usize get_ghost_type_index(const string& name) const {
-        return mapper.at(name);
-    }
-
-    const string& get_ghost_name(usize index) const {
-        return ghost_name.at(index);
-    }
-
-    usize register_ghost_type(const std::string& name, dtor ptr) {
-        if (mapper.count(name)) {
-            std::cerr<<"nasal_gc.h: ghost_register_table::register_ghost_type: ";
-            std::cerr<<"ghost type \""<<name<<"\" already exists.\n";
-            std::exit(1);
-        }
-        auto res=destructors.size();
-        mapper[name]=res;
-        ghost_name.push_back(name);
-        destructors.push_back(ptr);
-        return res;
-    }
-
-    dtor destructor(usize index) {
-        return destructors.at(index);
-    }
-};
-
-struct nas_ghost {
-public:
-    usize type;
-    void* ptr;
-
-private:
-    ghost_register_table* ghost_type_table;
-
-public:
-    nas_ghost(): type(0), ptr(nullptr), ghost_type_table(nullptr) {}
-    ~nas_ghost() {clear();}
-    void set(usize, void*, ghost_register_table*);
-    void clear();
-
-public:
-    friend std::ostream& operator<<(std::ostream& out, nas_ghost& ghost) {
-        out<<"<object "<<ghost.ghost_type_table->get_ghost_name(ghost.type);
-        out<<" at 0x"<<std::hex<<(u64)ghost.ptr<<std::dec<<">";
-        return out;
-    }
-
-    const std::string& get_ghost_name() const {
-        return ghost_type_table->get_ghost_name(type);
-    }
-};
-
-struct context {
-    u32  pc;
-    var* localr;
-    var* memr;
-    var  funcr;
-    var  upvalr;
-    var* canary;
-    var* stack;
-    var* top;
-};
-
-struct nas_co {
-    var stack[STACK_DEPTH];
-    context ctx;
-    coroutine_status status;
-
-    nas_co() {clear();}
-    void clear();
-};
-
-struct nas_val {
-    gc_status mark;
-    u8 type; // value type
-    u8 unmut; // used to mark if a string is unmutable
-    union {
-        string*    str;
-        nas_vec*   vec;
-        nas_hash*  hash;
-        nas_func*  func;
-        nas_upval* upval;
-        nas_ghost* obj;
-        nas_co*    co;
-    } ptr;
-
-    nas_val(u8);
-    ~nas_val();
-    void clear();
-};
-
-var nas_vec::get_val(const i32 n) {
-    i32 size=elems.size();
-    if (n<-size || n>=size) {
-        return var::none();
-    }
-    return elems[n>=0?n:n+size];
-}
-
-var* nas_vec::get_mem(const i32 n) {
-    i32 size=elems.size();
-    if (n<-size || n>=size) {
-        return nullptr;
-    }
-    return &elems[n>=0?n:n+size];
-}
-
-std::ostream& operator<<(std::ostream& out, nas_vec& vec) {
-    if (!vec.elems.size() || vec.printed) {
-        out<<(vec.elems.size()?"[..]":"[]");
-        return out;
-    }
-    vec.printed=true;
-    usize iter=0,size=vec.elems.size();
-    out<<'[';
-    for(auto& i:vec.elems) {
-        out<<i<<",]"[(++iter)==size];
-    }
-    vec.printed=false;
-    return out;
-}
-
-var nas_hash::get_val(const string& key) {
-    if (elems.count(key)) {
-        return elems.at(key);
-    } else if (!elems.count("parents")) {
-        return var::none();
-    }
-    var ret=var::none();
-    var val=elems.at("parents");
-    if (val.type!=vm_vec) {
-        return ret;
-    }
-    for(auto& i:val.vec().elems) {
-        if (i.type==vm_hash) {
-            ret=i.hash().get_val(key);
-        }
-        if (ret.type!=vm_none) {
-            return ret;
-        }
-    }
-    return ret;
-}
-
-var* nas_hash::get_mem(const string& key) {
-    if (elems.count(key)) {
-        return &elems.at(key);
-    } else if (!elems.count("parents")) {
-        return nullptr;
-    }
-    var* addr=nullptr;
-    var val=elems.at("parents");
-    if (val.type!=vm_vec) {
-        return addr;
-    }
-    for(auto& i:val.vec().elems) {
-        if (i.type==vm_hash) {
-            addr=i.hash().get_mem(key);
-        }
-        if (addr) {
-            return addr;
-        }
-    }
-    return addr;
-}
-
-std::ostream& operator<<(std::ostream& out, nas_hash& hash) {
-    if (!hash.elems.size() || hash.printed) {
-        out<<(hash.elems.size()?"{..}":"{}");
-        return out;
-    }
-    hash.printed=true;
-    usize iter=0,size=hash.elems.size();
-    out<<'{';
-    for(auto& i:hash.elems) {
-        out<<i.first<<':'<<i.second<<",}"[(++iter)==size];
-    }
-    hash.printed=false;
-    return out;
-}
-
-void nas_func::clear() {
-    dpara=-1;
-    local.clear();
-    upval.clear();
-    keys.clear();
-}
-
-void nas_ghost::set(usize t, void* p, ghost_register_table* table) {
-    type=t;
-    ptr=p;
-    ghost_type_table=table;
-}
-
-void nas_ghost::clear() {
-    if (!ptr) {
-        return;
-    }
-    ghost_type_table->destructor(type)(ptr);
-    ptr=nullptr;
-}
-
-void nas_co::clear() {
-    for(u32 i=0;i<STACK_DEPTH;++i) {
-        stack[i]=var::nil();
-    }
-    ctx.pc=0;
-    ctx.localr=nullptr;
-    ctx.memr=nullptr;
-    ctx.canary=stack+STACK_DEPTH-1;
-    ctx.top=stack;
-    ctx.funcr=var::nil();
-    ctx.upvalr=var::nil();
-    ctx.stack=stack;
-
-    status=coroutine_status::suspended;
-}
-
-nas_val::nas_val(u8 val_type) {
-    mark=gc_status::collected;
-    type=val_type;
-    unmut=0;
-    switch(val_type) {
-        case vm_str:  ptr.str=new string;     break;
-        case vm_vec:  ptr.vec=new nas_vec;    break;
-        case vm_hash: ptr.hash=new nas_hash;  break;
-        case vm_func: ptr.func=new nas_func;  break;
-        case vm_upval:ptr.upval=new nas_upval;break;
-        case vm_obj:  ptr.obj=new nas_ghost;  break;
-        case vm_co:   ptr.co=new nas_co;      break;
-    }
-}
-
-nas_val::~nas_val() {
-    switch(type) {
-        case vm_str:  delete ptr.str;  break;
-        case vm_vec:  delete ptr.vec;  break;
-        case vm_hash: delete ptr.hash; break;
-        case vm_func: delete ptr.func; break;
-        case vm_upval:delete ptr.upval;break;
-        case vm_obj:  delete ptr.obj;  break;
-        case vm_co:   delete ptr.co;   break;
-    }
-    type=vm_nil;
-}
-
-void nas_val::clear() {
-    switch(type) {
-        case vm_str:  ptr.str->clear();       break;
-        case vm_vec:  ptr.vec->elems.clear(); break;
-        case vm_hash: ptr.hash->elems.clear();break;
-        case vm_func: ptr.func->clear();      break;
-        case vm_upval:ptr.upval->clear();     break;
-        case vm_obj:  ptr.obj->clear();       break;
-        case vm_co:   ptr.co->clear();        break;
-    }
-}
-
-f64 var::tonum() {
-    return type!=vm_str? val.num:str2num(str().c_str());
-}
-
-string var::tostr() {
-    if (type==vm_str) {
-        return str();
-    } else if (type==vm_num) {
-        string tmp=std::to_string(num());
-        tmp.erase(tmp.find_last_not_of('0')+1, string::npos);
-        tmp.erase(tmp.find_last_not_of('.')+1, string::npos);
-        return tmp;
-    }
-    return "";
-}
-
-std::ostream& operator<<(std::ostream& out, var& ref) {
-    switch(ref.type) {
-        case vm_none: out<<"undefined";   break;
-        case vm_nil:  out<<"nil";         break;
-        case vm_num:  out<<ref.val.num;   break;
-        case vm_str:  out<<ref.str();     break;
-        case vm_vec:  out<<ref.vec();     break;
-        case vm_hash: out<<ref.hash();    break;
-        case vm_func: out<<"func(..) {..}";break;
-        case vm_obj:  out<<ref.obj();     break;
-        case vm_co:   out<<"<coroutine>"; break;
-    }
-    return out;
-}
-
-bool var::objchk(usize obj_type) {
-    return type==vm_obj && obj().type==obj_type && obj().ptr;
-}
-
-var var::none() {
-    return {vm_none, (u32)0};
-}
-
-var var::nil() {
-    return {vm_nil, (u32)0};
-}
-
-var var::ret(u32 pc) {
-    return {vm_ret, pc};
-}
-
-var var::cnt(i64 n) {
-    return {vm_cnt, n};
-}
-
-var var::num(f64 n) {
-    return {vm_num, n};
-}
-
-var var::gcobj(nas_val* p) {
-    return {p->type, p};
-}
-
-var var::addr(var* p) {
-    return {vm_addr, p};
-}
-
-var*       var::addr () {return val.addr;             }
-u32        var::ret  () {return val.ret;              }
-i64&       var::cnt  () {return val.cnt;              }
-f64        var::num  () {return val.num;              }
-string&    var::str  () {return *val.gcobj->ptr.str;  }
-nas_vec&   var::vec  () {return *val.gcobj->ptr.vec;  }
-nas_hash&  var::hash () {return *val.gcobj->ptr.hash; }
-nas_func&  var::func () {return *val.gcobj->ptr.func; }
-nas_upval& var::upval() {return *val.gcobj->ptr.upval;}
-nas_ghost& var::obj  () {return *val.gcobj->ptr.obj;  }
-nas_co&    var::co   () {return *val.gcobj->ptr.co;   }
-
-const var zero=var::num(0);
-const var one =var::num(1);
-const var nil =var::nil();
-
-struct gc {
-    ghost_register_table global_ghost_type_table;
-    /* main context temporary storage */
-    context mctx;
-
-    /* runtime context */
-    context* rctx;
-    nas_co* cort=nullptr; // running coroutine
-
-    /*  temporary space used in builtin/module functions */
-    var temp=nil;
-
-    /* constants and memory pool */
-    std::vector<var> strs;        // reserved address for const vm_str
-    std::vector<var> env_argv;    // command line arguments
-    std::vector<nas_val*> memory; // gc memory
-    std::vector<nas_val*> unused[gc_type_size]; // gc free list
-
-    /* heap increase size */
-    u32 incr[gc_type_size]={
-        128, // vm_str
-        128, // vm_vec
-        64,  // vm_hash
-        128, // vm_func
-        256, // vm_upval
-        16,  // vm_obj
-        16   // vm_co
-    };
-
-    /* values for analysis */
-    u64 size[gc_type_size];
-    u64 gcnt[gc_type_size];
-    u64 acnt[gc_type_size];
-    i64 worktime=0;
-
-    gc(context* _ctx): rctx(_ctx) {}
-
-private:
-    /* gc functions */
-    void mark();
-    void mark_context(std::vector<var>&);
-    void mark_var(std::vector<var>&, var&);
-    inline void mark_vec(std::vector<var>&, nas_vec&);
-    inline void mark_hash(std::vector<var>&, nas_hash&);
-    inline void mark_func(std::vector<var>&, nas_func&);
-    inline void mark_upval(std::vector<var>&, nas_upval&);
-    inline void mark_co(std::vector<var>&, nas_co&);
-    void sweep();
-
-public:
-    void extend(u8);
-    void init(const std::vector<string>&, const std::vector<string>&);
-    void clear();
-    void info();
-    var alloc(const u8);
-    void ctxchg(nas_co&);
-    void ctxreserve();
-
-public:
-    var newstr(char c) {
-        var s=alloc(vm_str);
-        s.str()=c;
-        return s;
-    }
-
-    var newstr(const char* buff) {
-        var s=alloc(vm_str);
-        s.str()=buff;
-        return s;
-    }
-
-    var newstr(const string& buff) {
-        var s=alloc(vm_str);
-        s.str()=buff;
-        return s;
-    }
-};
-
-void gc::mark() {
-    std::vector<var> bfs;
-    mark_context(bfs);
-    
-    while(!bfs.empty()) {
-        var value=bfs.back();
-        bfs.pop_back();
-        if (value.type<=vm_num ||
-            value.val.gcobj->mark!=gc_status::uncollected) {
-            continue;
-        }
-        mark_var(bfs, value);
-    }
-}
-
-void gc::mark_context(std::vector<var>& bfs_queue) {
-
-    // scan now running context, this context maybe related to coroutine or main
-    for(var* i=rctx->stack;i<=rctx->top;++i) {
-        bfs_queue.push_back(*i);
-    }
-    bfs_queue.push_back(rctx->funcr);
-    bfs_queue.push_back(rctx->upvalr);
-    bfs_queue.push_back(temp);
-
-    if (!cort) {
-        return;
-    }
-
-    // coroutine is running, so scan main process stack from mctx
-    for(var* i=mctx.stack;i<=mctx.top;++i) {
-        bfs_queue.push_back(*i);
-    }
-    bfs_queue.push_back(mctx.funcr);
-    bfs_queue.push_back(mctx.upvalr);
-}
-
-void gc::mark_var(std::vector<var>& bfs_queue, var& value) {
-    value.val.gcobj->mark=gc_status::found;
-    switch(value.type) {
-        case vm_vec: mark_vec(bfs_queue, value.vec()); break;
-        case vm_hash: mark_hash(bfs_queue, value.hash()); break;
-        case vm_func: mark_func(bfs_queue, value.func()); break;
-        case vm_upval: mark_upval(bfs_queue, value.upval()); break;
-        case vm_co: mark_co(bfs_queue, value.co()); break;
-        default: break;
-    }
-}
-
-void gc::mark_vec(std::vector<var>& bfs_queue, nas_vec& vec) {
-    for(auto& i:vec.elems) {
-        bfs_queue.push_back(i);
-    }
-}
-
-void gc::mark_hash(std::vector<var>& bfs_queue, nas_hash& hash) {
-    for(auto& i:hash.elems) {
-        bfs_queue.push_back(i.second);
-    }
-}
-
-void gc::mark_func(std::vector<var>& bfs_queue, nas_func& function) {
-    for(auto& i:function.local) {
-        bfs_queue.push_back(i);
-    }
-    for(auto& i:function.upval) {
-        bfs_queue.push_back(i);
-    }
-}
-
-void gc::mark_upval(std::vector<var>& bfs_queue, nas_upval& upval) {
-    for(auto& i:upval.elems) {
-        bfs_queue.push_back(i);
-    }
-}
-
-void gc::mark_co(std::vector<var>& bfs_queue, nas_co& co) {
-    bfs_queue.push_back(co.ctx.funcr);
-    bfs_queue.push_back(co.ctx.upvalr);
-    for(var* i=co.stack;i<=co.ctx.top;++i) {
-        bfs_queue.push_back(*i);
-    }
-}
-
-void gc::sweep() {
-    for(auto i:memory) {
-        if (i->mark==gc_status::uncollected) {
-            i->clear();
-            unused[i->type-vm_str].push_back(i);
-            i->mark=gc_status::collected;
-        } else if (i->mark==gc_status::found) {
-            i->mark=gc_status::uncollected;
-        }
-    }
-}
-
-void gc::extend(u8 type) {
-    const u8 index=type-vm_str;
-    size[index]+=incr[index];
-
-    for(u32 i=0;i<incr[index];++i) {
-        nas_val* tmp=new(std::nothrow) nas_val(type);
-
-        if (!tmp) {
-            std::cerr<<"nasal_gc.h: gc::extend: ";
-            std::cerr<<"failed to allocate memory\n";
-            std::exit(1);
-        }
-
-        // add to heap
-        memory.push_back(tmp);
-        unused[index].push_back(tmp);
-    }
-
-    incr[index]=incr[index]+incr[index]/2;
-}
-
-void gc::init(const std::vector<string>& s, const std::vector<string>& argv) {
-    // initialize function register
-    rctx->funcr=nil;
-    worktime=0;
-
-    // initialize counters
-    for(u8 i=0;i<gc_type_size;++i) {
-        size[i]=gcnt[i]=acnt[i]=0;
-    }
-
-    // coroutine pointer set to nullptr
-    cort=nullptr;
-
-    // init constant strings
-    strs.resize(s.size());
-    for(u32 i=0;i<strs.size();++i) {
-        strs[i]=var::gcobj(new nas_val(vm_str));
-        strs[i].val.gcobj->unmut=1;
-        strs[i].str()=s[i];
-    }
-
-    // record arguments
-    env_argv.resize(argv.size());
-    for(usize i=0;i<argv.size();++i) {
-        env_argv[i]=var::gcobj(new nas_val(vm_str));
-        env_argv[i].val.gcobj->unmut=1;
-        env_argv[i].str()=argv[i];
-    }
-}
-
-void gc::clear() {
-    for(auto i:memory) {
-        delete i;
-    }
-    memory.clear();
-    for(u8 i=0;i<gc_type_size;++i) {
-        unused[i].clear();
-    }
-    for(auto& i:strs) {
-        delete i.val.gcobj;
-    }
-    strs.clear();
-    env_argv.clear();
-}
-
-void gc::info() {
-    using std::left;
-    using std::setw;
-    using std::setfill;
-    const char* name[]={"str  ","vec  ","hash ","func ","upval","obj  ","co   "};
-    std::clog<<"\ngc info (gc count|alloc count|memory size)\n";
-
-    usize ident=0;
-    for(u8 i=0;i<gc_type_size;++i) {
-#ifndef _MSC_VER
-        usize len=std::max({
-            std::to_string(gcnt[i]).length(),
-            std::to_string(acnt[i]).length(),
-            std::to_string(size[i]).length()
-        });
-#else // VS is a piece of shit
-        usize len=std::to_string(gcnt[i]).length();
-        ident=ident<len?len:ident;
-        len=std::to_string(acnt[i]).length();
-        ident=ident<len?len:ident;
-        len=std::to_string(size[i]).length();
-#endif
-        ident=ident<len?len:ident;
-    }
-
-    double total=0;
-    for(u8 i=0;i<gc_type_size;++i) {
-        if (gcnt[i] || acnt[i] || size[i]) {
-            total+=gcnt[i];
-            std::clog<<" "<<name[i];
-            std::clog<<" | "<<left<<setw(ident)<<setfill(' ')<<gcnt[i];
-            std::clog<<" | "<<left<<setw(ident)<<setfill(' ')<<acnt[i];
-            std::clog<<" | "<<left<<setw(ident)<<setfill(' ')<<size[i];
-            std::clog<<"\n";
-        }
-    }
-
-    double sec=worktime*1.0/1000000000; // seconds
-    std::clog<<" time  | "<<(sec<0.1? sec*1000:sec)<<(sec<0.1? " ms\n":" s\n");
-    if (total) {
-        std::clog<<" avg   | "<<sec/total*1000<<" ms\n";
-    }
-    std::clog<<"\n";
-}
-
-var gc::alloc(u8 type) {
-    using clk=std::chrono::high_resolution_clock;
-    const u8 index=type-vm_str;
-    ++acnt[index];
-    if (unused[index].empty()) {
-        ++gcnt[index];
-        auto begin=clk::now();
-        mark();
-        sweep();
-        worktime+=(clk::now()-begin).count();
-    }
-    if (unused[index].empty()) {
-        extend(type);
-    }
-    var ret=var::gcobj(unused[index].back());
-    ret.val.gcobj->mark=gc_status::uncollected;
-    unused[index].pop_back();
-    return ret;
-}
-
-void gc::ctxchg(nas_co& co) {
-    // store running state to main context
-    mctx=*rctx;
-
-    // restore coroutine context state
-    *rctx=co.ctx;
-
-    // set coroutine pointer
-    cort=&co;
-
-    // set coroutine state to running
-    cort->status=coroutine_status::running;
-}
-
-void gc::ctxreserve() {
-    // pc=0 means this coroutine is finished
-    cort->status=rctx->pc?
-        coroutine_status::suspended:
-        coroutine_status::dead;
-
-    // store running state to coroutine
-    cort->ctx=*rctx;
-
-    // restore main context state
-    *rctx=mctx;
-
-    // set coroutine pointer to nullptr
-    cort=nullptr;
-}
-
-// use to print error log and return error value
-var nas_err(const string& error_function_name, const string& info) {
-    std::cerr<<"[vm] "<<error_function_name<<": "<<info<<"\n";
-    return var::none();
-}
-
-// module function type
-typedef var (*module_func)(var*, usize, gc*);
-
-// module function stores in tables with this type, end with {nullptr,nullptr}
-struct module_func_info {
-    const char* name;
-    module_func fd;
-};
-
-// module function "get" type
-typedef module_func_info* (*get_func_ptr)(ghost_register_table*);
diff --git a/nasal_import.h b/nasal_import.h
deleted file mode 100644
index 984fcf8..0000000
--- a/nasal_import.h
+++ /dev/null
@@ -1,226 +0,0 @@
-#pragma once
-
-#ifndef _MSC_VER
-#include <unistd.h>
-#else
-#define _CRT_SECURE_NO_DEPRECATE 1
-#define _CRT_NONSTDC_NO_DEPRECATE 1
-#include <io.h>
-#endif
-
-#ifdef _MSC_VER
-#define F_OK 0
-#endif
-
-#include "nasal.h"
-#include "nasal_ast.h"
-#include "nasal_lexer.h"
-#include "nasal_parse.h"
-
-class linker{
-private:
-    bool show_path;
-    bool lib_loaded;
-    error& err;
-    std::vector<string> files;
-    std::vector<string> envpath;
-
-    bool imptchk(const ast&);
-    bool exist(const string&);
-    void link(ast&, ast&&);
-    string path(const ast&);
-    string findf(const string&);
-    ast fimpt(ast&);
-    ast libimpt();
-    ast load(ast&, u16);
-public:
-    linker(error&);
-    const error& link(parse&, const string&, bool);
-    const std::vector<string>& filelist() const {return files;}
-};
-
-linker::linker(error& e): show_path(false), lib_loaded(false), err(e) {
-    char sep=is_windows()? ';':':';
-    string PATH=getenv("PATH");
-    usize last=0;
-    usize pos=PATH.find(sep, 0);
-    while(pos!=string::npos) {
-        string dirpath=PATH.substr(last, pos-last);
-        if (dirpath.length()) {
-            envpath.push_back(dirpath);
-        }
-        last=pos+1;
-        pos=PATH.find(sep, last);
-    }
-    if (last!=PATH.length()) {
-        envpath.push_back(PATH.substr(last));
-    }
-}
-
-string linker::path(const ast& node) {
-    if (node[1].type()==ast_callf) {
-        return node[1][0].str();
-    }
-    string fpath=".";
-    for(usize i=1;i<node.size();++i) {
-        fpath+=(is_windows()? "\\":"/")+node[i].str();
-    }
-    return fpath+".nas";
-}
-
-string linker::findf(const string& fname) {
-    // first add file name itself into the file path
-    std::vector<string> fpath={fname};
-
-    // generate search path from environ path
-    for(auto&p:envpath) {
-        fpath.push_back(p+(is_windows()? "\\":"/")+fname);
-    }
-
-    // search file
-    for(auto& i:fpath) {
-        if (access(i.c_str(), F_OK)!=-1) {
-            return i;
-        }
-    }
-
-    // we will find lib.nas in nasal std directory
-    if (fname=="lib.nas") {
-        return is_windows()? findf("std\\lib.nas"):findf("std/lib.nas");
-    }
-    if (!show_path) {
-        err.err("link", "cannot find file <"+fname+">");
-        return "";
-    }
-    string paths="";
-    for(auto& i:fpath) {
-        paths+="  "+i+"\n";
-    }
-    err.err("link", "cannot find file <"+fname+"> in these paths:\n"+paths);
-    return "";
-}
-
-bool linker::imptchk(const ast& node) {
-// only these two kinds of node can be recognized as 'import':
-/*
-    call
-    |_id:import
-    |_callh:std
-    |_callh:file
-*/
-    if (node.type()==ast_call && node[0].str()=="import" && node.size()>=2 && node[1].type()==ast_callh) {
-        for(usize i=1;i<node.size();++i) {
-            if (node[i].type()!=ast_callh) {
-                return false;
-            }
-        }
-        return true;
-    }
-/*
-    call
-    |_id:import
-    |_call_func
-      |_string:'filename'
-*/
-    return (
-        node.type()==ast_call &&
-        node[0].str()=="import" &&
-        node.size()==2 &&
-        node[1].type()==ast_callf &&
-        node[1].size()==1 &&
-        node[1][0].type()==ast_str
-    );
-}
-
-bool linker::exist(const string& file) {
-    // avoid importing the same file
-    for(auto& fname:files) {
-        if (file==fname) {
-            return true;
-        }
-    }
-    files.push_back(file);
-    return false;
-}
-
-void linker::link(ast& root, ast&& add_root) {
-    // add children of add_root to the back of root
-    for(auto& i:add_root.child()) {
-        root.add(std::move(i));
-    }
-}
-
-ast linker::fimpt(ast& node) {
-    lexer lex(err);
-    parse par(err);
-    // get filename and set node to ast_null
-    string filename=path(node);
-    node.clear();
-
-    // avoid infinite loading loop
-    filename=findf(filename);
-    if (!filename.length() || exist(filename)) {
-        return {{0, 0, 0, 0, filename}, ast_root};
-    }
-    
-    // start importing...
-    lex.scan(filename);
-    par.compile(lex);
-    ast tmp=std::move(par.tree());
-
-    // check if tmp has 'import'
-    return load(tmp, files.size()-1);
-}
-
-ast linker::libimpt() {
-    lexer lex(err);
-    parse par(err);
-    string filename=findf("lib.nas");
-    if (!filename.length()) {
-        return {{0, 0, 0, 0, filename}, ast_root};
-    }
-
-    // avoid infinite loading loop
-    if (exist(filename)) {
-        return {{0, 0, 0, 0, filename}, ast_root};
-    }
-    
-    // start importing...
-    lex.scan(filename);
-    par.compile(lex);
-    ast tmp=std::move(par.tree());
-
-    // check if tmp has 'import'
-    return load(tmp, files.size()-1);
-}
-
-ast linker::load(ast& root, u16 fileindex) {
-    ast tree({0, 0, 0, 0, files[fileindex]}, ast_root);
-    if (!lib_loaded) {
-        link(tree, libimpt());
-        lib_loaded=true;
-    }
-    for(auto& i:root.child()) {
-        if (imptchk(i)) {
-            link(tree, fimpt(i));
-        } else {
-            break;
-        }
-    }
-    // add root to the back of tree
-    ast file_head({0, 0, 0, 0, files[fileindex]}, ast_file);
-    file_head.set_num(fileindex);
-    tree.add(std::move(file_head));
-    link(tree, std::move(root));
-    return tree;
-}
-
-const error& linker::link(parse& parse, const string& self, bool spath=false) {
-    show_path=spath;
-    // initializing
-    files={self};
-    // scan root and import files,then generate a new ast and return to import_ast
-    // the main file's index is 0
-    parse.tree()=load(parse.tree(), 0);
-    return err;
-}
diff --git a/nasal_lexer.h b/nasal_lexer.h
deleted file mode 100644
index b6cae34..0000000
--- a/nasal_lexer.h
+++ /dev/null
@@ -1,506 +0,0 @@
-#pragma once
-#ifdef _MSC_VER
-#pragma warning (disable:4244)
-#pragma warning (disable:4267)
-#pragma warning (disable:4102)
-#endif
-
-#include <cstring>
-#include <sstream>
-#include <vector>
-#include <unordered_map>
-#include <sys/stat.h>
-
-#include "nasal.h"
-#include "nasal_err.h"
-
-#ifdef _MSC_VER
-#define S_ISREG(m) (((m)&0xF000)==0x8000)
-#endif
-
-enum class tok:u32 {
-    null=0,   // null token (default token type)
-    num,      // number literal
-    str,      // string literal
-    id,       // identifier
-    tktrue,   // keyword true
-    tkfalse,  // keyword false
-    rfor,     // loop keyword for
-    forindex, // loop keyword forindex
-    foreach,  // loop keyword foreach
-    rwhile,   // loop keyword while
-    var,      // keyword for definition
-    func,     // keyword for definition of function
-    brk,      // loop keyword break
-    cont,     // loop keyword continue
-    ret,      // function keyword return
-    rif,      // condition expression keyword if
-    elsif,    // condition expression keyword elsif
-    relse,    // condition expression keyword else
-    tknil,    // nil literal
-    lcurve,   // (
-    rcurve,   // )
-    lbracket, // [
-    rbracket, // ]
-    lbrace,   // {
-    rbrace,   // }
-    semi,     // ;
-    opand,    // operator and
-    opor,     // operator or
-    comma,    // ,
-    dot,      // .
-    ellipsis, // ...
-    quesmark, // ?
-    colon,    // :
-    add,      // operator +
-    sub,      // operator -
-    mult,     // operator *
-    div,      // operator /
-    floater,  // operator ~ and binary operator ~
-    btand,    // bitwise operator &
-    btor,     // bitwise operator |
-    btxor,    // bitwise operator ^
-    opnot,    // operator !
-    eq,       // operator =
-    addeq,    // operator +=
-    subeq,    // operator -=
-    multeq,   // operator *=
-    diveq,    // operator /=
-    lnkeq,    // operator ~=
-    btandeq,  // operator &=
-    btoreq,   // operator |=
-    btxoreq,  // operator ^=
-    cmpeq,    // operator ==
-    neq,      // operator !=
-    less,     // operator <
-    leq,      // operator <=
-    grt,      // operator >
-    geq,      // operator >=
-    eof       // <eof> end of token list
-};
-
-struct token {
-    span loc;    // location
-    tok type;    // token type
-    string str;  // content
-    token() = default;
-    token(const token&) = default;
-};
-
-class lexer {
-private:
-    u32    line;
-    u32    column;
-    usize  ptr;
-    string filename;
-    string res;
-    error& err;
-    std::vector<token> toks;
-    const std::unordered_map<string,tok> typetbl {
-        {"true"    ,tok::tktrue  },
-        {"false"   ,tok::tkfalse },
-        {"for"     ,tok::rfor    },
-        {"forindex",tok::forindex},
-        {"foreach" ,tok::foreach },
-        {"while"   ,tok::rwhile  },
-        {"var"     ,tok::var     },
-        {"func"    ,tok::func    },
-        {"break"   ,tok::brk     },
-        {"continue",tok::cont    },
-        {"return"  ,tok::ret     },
-        {"if"      ,tok::rif     },
-        {"elsif"   ,tok::elsif   },
-        {"else"    ,tok::relse   },
-        {"nil"     ,tok::tknil   },
-        {"("       ,tok::lcurve  },
-        {")"       ,tok::rcurve  },
-        {"["       ,tok::lbracket},
-        {"]"       ,tok::rbracket},
-        {"{"       ,tok::lbrace  },
-        {"}"       ,tok::rbrace  },
-        {";"       ,tok::semi    },
-        {"and"     ,tok::opand   },
-        {"or"      ,tok::opor    },
-        {","       ,tok::comma   },
-        {"."       ,tok::dot     },
-        {"..."     ,tok::ellipsis},
-        {"?"       ,tok::quesmark},
-        {":"       ,tok::colon   },
-        {"+"       ,tok::add     },
-        {"-"       ,tok::sub     },
-        {"*"       ,tok::mult    },
-        {"/"       ,tok::div     },
-        {"~"       ,tok::floater },
-        {"&"       ,tok::btand   },
-        {"|"       ,tok::btor    },
-        {"^"       ,tok::btxor   },
-        {"!"       ,tok::opnot   },
-        {"="       ,tok::eq      },
-        {"+="      ,tok::addeq   },
-        {"-="      ,tok::subeq   },
-        {"*="      ,tok::multeq  },
-        {"/="      ,tok::diveq   },
-        {"~="      ,tok::lnkeq   },
-        {"&="      ,tok::btandeq },
-        {"|="      ,tok::btoreq  },
-        {"^="      ,tok::btxoreq },
-        {"=="      ,tok::cmpeq   },
-        {"!="      ,tok::neq     },
-        {"<"       ,tok::less    },
-        {"<="      ,tok::leq     },
-        {">"       ,tok::grt     },
-        {">="      ,tok::geq     }
-    };
-
-    tok get_type(const string&);
-    bool skip(char);
-    bool is_id(char);
-    bool is_hex(char);
-    bool is_oct(char);
-    bool is_dec(char);
-    bool is_str(char);
-    bool is_single_opr(char);
-    bool is_calc_opr(char);
-
-    void skip_note();
-    void err_char();
-
-    void open(const string&);
-    string utf8_gen();
-    token id_gen();
-    token num_gen();
-    token str_gen();
-    token single_opr();
-    token dots();
-    token calc_opr();
-public:
-    lexer(error& e): line(1), column(0), ptr(0), filename(""), res(""), err(e) {}
-    const error& scan(const string&);
-    const std::vector<token>& result() const {return toks;}
-};
-
-bool lexer::skip(char c) {
-    return c==' '||c=='\n'||c=='\t'||c=='\r'||c==0;
-}
-
-bool lexer::is_id(char c) {
-    return (c=='_')||('a'<=c && c<='z')||('A'<=c&&c<='Z')||(c<0);   
-}
-
-bool lexer::is_hex(char c) {
-    return ('0'<=c&&c<='9')||('a'<=c&&c<='f')||('A'<=c && c<='F');
-}
-
-bool lexer::is_oct(char c) {
-    return '0'<=c&&c<='7';
-}
-
-bool lexer::is_dec(char c) {
-    return '0'<=c&&c<='9';
-}
-
-bool lexer::is_str(char c) {
-    return c=='\''||c=='\"'||c=='`';
-}
-
-bool lexer::is_single_opr(char c) {
-    return (
-        c=='('||c==')'||c=='['||c==']'||
-        c=='{'||c=='}'||c==','||c==';'||
-        c==':'||c=='?'||c=='`'||c=='@'||
-        c=='%'||c=='$'||c=='\\'
-    );
-}
-
-bool lexer::is_calc_opr(char c) {
-    return (
-        c=='='||c=='+'||c=='-'||c=='*'||
-        c=='!'||c=='/'||c=='<'||c=='>'||
-        c=='~'||c=='|'||c=='&'||c=='^'
-    );
-}
-
-void lexer::skip_note() {
-    // avoid note, after this process ptr will point to a '\n', so next loop line counter+1
-    while(++ptr<res.size() && res[ptr]!='\n') {}
-}
-
-void lexer::err_char() {
-    ++column;
-    char c=res[ptr++];
-    err.err("lexer", {line, column-1, line, column, filename}, "invalid character 0x"+chrhex(c));
-    err.fatal("lexer", "fatal error occurred, stop");
-}
-
-void lexer::open(const string& file) {
-    // check file exsits and it is a regular file
-    struct stat buffer;
-    if (stat(file.c_str(), &buffer)==0 && !S_ISREG(buffer.st_mode)) {
-        err.err("lexer", "<"+file+"> is not a regular file");
-        err.chkerr();
-    }
-
-    // load
-    filename=file;
-    std::ifstream in(file, std::ios::binary);
-    if (in.fail()) {
-        err.err("lexer", "failed to open <"+file+">");
-    } else {
-        err.load(file);
-    }
-    std::stringstream ss;
-    ss<<in.rdbuf();
-    res=ss.str();
-}
-
-tok lexer::get_type(const string& str) {
-    return typetbl.count(str)?typetbl.at(str):tok::null;
-}
-
-string lexer::utf8_gen() {
-    string str="";
-    while(ptr<res.size() && res[ptr]<0) {
-        string tmp="";
-        u32 nbytes=utf8_hdchk(res[ptr]);
-        if (!nbytes) {
-            ++ptr;
-            ++column;
-            continue;
-        }
-
-        tmp+=res[ptr++];
-        for(u32 i=0;i<nbytes;++i,++ptr) {
-            if (ptr<res.size() && (res[ptr]&0xc0)==0x80) {
-                tmp+=res[ptr];
-            }
-        }
-
-        // utf8 character's total length is 1+nbytes
-        if (tmp.length()!=1+nbytes) {
-            ++column;
-            string utf_info="0x"+chrhex(tmp[0]);
-            for(u32 i=1;i<tmp.size();++i) {
-                utf_info+=" 0x"+chrhex(tmp[i]);
-            }
-            err.err("lexer", {line, column-1, line, column, filename}, "invalid utf-8 <"+utf_info+">");
-            err.fatal("lexer", "fatal error occurred, stop");
-        }
-        str+=tmp;
-        column+=2; // may have some problems because not all the unicode takes 2 space
-    }
-    return str;
-}
-
-token lexer::id_gen() {
-    u32 begin_line=line;
-    u32 begin_column=column;
-    string str="";
-    while(ptr<res.size() && (is_id(res[ptr])||is_dec(res[ptr]))) {
-        if (res[ptr]<0) { // utf-8
-            str+=utf8_gen();
-        } else { // ascii
-            str+=res[ptr++];
-            ++column;
-        }
-    }
-    tok type=get_type(str);
-    return {{begin_line, begin_column, line, column, filename}, (type!=tok::null)?type:tok::id, str};
-}
-
-token lexer::num_gen() {
-    u32 begin_line=line;
-    u32 begin_column=column;
-    // generate hex number
-    if (ptr+1<res.size() && res[ptr]=='0' && res[ptr+1]=='x') {
-        string str="0x";
-        ptr+=2;
-        while(ptr<res.size() && is_hex(res[ptr])) {
-            str+=res[ptr++];
-        }
-        column+=str.length();
-        if (str.length()<3) { // "0x"
-            err.err("lexer", {begin_line, begin_column, line, column, filename}, "invalid number `"+str+"`");
-        }
-        return {{begin_line, begin_column, line, column, filename}, tok::num, str};
-    } else if (ptr+1<res.size() && res[ptr]=='0' && res[ptr+1]=='o') { // generate oct number
-        string str="0o";
-        ptr+=2;
-        while(ptr<res.size() && is_oct(res[ptr])) {
-            str+=res[ptr++];
-        }
-        bool erfmt=false;
-        while(ptr<res.size() && (is_dec(res[ptr]) || is_hex(res[ptr]))) {
-            erfmt=true;
-            str+=res[ptr++];
-        }
-        column+=str.length();
-        if (str.length()==2 || erfmt) {
-            err.err("lexer", {begin_line, begin_column, line, column, filename}, "invalid number `"+str+"`");
-        }
-        return {{begin_line, begin_column, line, column, filename}, tok::num, str};
-    }
-    // generate dec number
-    // dec number -> [0~9][0~9]*(.[0~9]*)(e|E(+|-)0|[1~9][0~9]*)
-    string str="";
-    while(ptr<res.size() && is_dec(res[ptr])) {
-        str+=res[ptr++];
-    }
-    if (ptr<res.size() && res[ptr]=='.') {
-        str+=res[ptr++];
-        while(ptr<res.size() && is_dec(res[ptr])) {
-            str+=res[ptr++];
-        }
-        // "xxxx." is not a correct number
-        if (str.back()=='.') {
-            column+=str.length();
-            err.err("lexer",{begin_line, begin_column, line, column, filename}, "invalid number `"+str+"`");
-            return {{begin_line, begin_column, line, column, filename}, tok::num, "0"};
-        }
-    }
-    if (ptr<res.size() && (res[ptr]=='e' || res[ptr]=='E')) {
-        str+=res[ptr++];
-        if (ptr<res.size() && (res[ptr]=='-' || res[ptr]=='+')) {
-            str+=res[ptr++];
-        }
-        while(ptr<res.size() && is_dec(res[ptr])) {
-            str+=res[ptr++];
-        }
-        // "xxxe(-|+)" is not a correct number
-        if (str.back()=='e' || str.back()=='E' || str.back()=='-' || str.back()=='+') {
-            column+=str.length();
-            err.err("lexer",{begin_line, begin_column, line, column, filename}, "invalid number `"+str+"`");
-            return {{begin_line, begin_column, line, column, filename}, tok::num, "0"};
-        }
-    }
-    column+=str.length();
-    return {{begin_line, begin_column, line, column, filename}, tok::num, str};
-}
-
-token lexer::str_gen() {
-    u32 begin_line=line;
-    u32 begin_column=column;
-    string str="";
-    const char begin=res[ptr];
-    ++column;
-    while(++ptr<res.size() && res[ptr]!=begin) {
-        ++column;
-        if (res[ptr]=='\n') {
-            column=0;
-            ++line;
-        }
-        if (res[ptr]=='\\' && ptr+1<res.size()) {
-            ++column;
-            ++ptr;
-            switch(res[ptr]) {
-                case '0': str+='\0';    break;
-                case 'a': str+='\a';    break;
-                case 'b': str+='\b';    break;
-                case 'e': str+='\033';  break;
-                case 't': str+='\t';    break;
-                case 'n': str+='\n';    break;
-                case 'v': str+='\v';    break;
-                case 'f': str+='\f';    break;
-                case 'r': str+='\r';    break;
-                case '?': str+='\?';    break;
-                case '\\':str+='\\';    break;
-                case '\'':str+='\'';    break;
-                case '\"':str+='\"';    break;
-                default:  str+=res[ptr];break;
-            }
-            if (res[ptr]=='\n') {
-                column=0;
-                ++line;
-            }
-            continue;
-        }
-        str+=res[ptr];
-    }
-    // check if this string ends with a " or '
-    if (ptr++>=res.size()) {
-        err.err("lexer", {begin_line, begin_column, line, column, filename}, "get EOF when generating string");
-        return {{begin_line, begin_column, line, column, filename}, tok::str, str};
-    }
-    ++column;
-    if (begin=='`' && str.length()!=1) {
-        err.err("lexer", {begin_line, begin_column, line, column, filename}, "\'`\' is used for string including one character");
-    }
-    return {{begin_line, begin_column, line, column, filename}, tok::str, str};
-}
-
-token lexer::single_opr() {
-    u32 begin_line=line;
-    u32 begin_column=column;
-    string str(1,res[ptr]);
-    ++column;
-    tok type=get_type(str);
-    if (type==tok::null) {
-        err.err("lexer", {begin_line, begin_column, line, column, filename}, "invalid operator `"+str+"`");
-    }
-    ++ptr;
-    return {{begin_line, begin_column, line, column, filename}, type, str};
-}
-
-token lexer::dots() {
-    u32 begin_line=line;
-    u32 begin_column=column;
-    string str=".";
-    if (ptr+2<res.size() && res[ptr+1]=='.' && res[ptr+2]=='.') {
-        str+="..";
-    }
-    ptr+=str.length();
-    column+=str.length();
-    return {{begin_line, begin_column, line, column, filename}, get_type(str), str};
-}
-
-token lexer::calc_opr() {
-    u32 begin_line=line;
-    u32 begin_column=column;
-    // get calculation operator
-    string str(1,res[ptr++]);
-    if (ptr<res.size() && res[ptr]=='=') {
-        str+=res[ptr++];
-    }
-    column+=str.length();
-    return {{begin_line, begin_column, line, column, filename}, get_type(str), str};
-}
-
-const error& lexer::scan(const string& file) {
-    line=1;
-    column=0;
-    ptr=0;
-    open(file);
-
-    while(ptr<res.size()) {
-        while(ptr<res.size() && skip(res[ptr])) {
-            // these characters will be ignored, and '\n' will cause ++line
-            ++column;
-            if (res[ptr++]=='\n') {
-                ++line;
-                column=0;
-            }
-        }
-        if (ptr>=res.size()) {
-            break;
-        }
-        if (is_id(res[ptr])) {
-            toks.push_back(id_gen());
-        } else if (is_dec(res[ptr])) {
-            toks.push_back(num_gen());
-        } else if (is_str(res[ptr])) {
-            toks.push_back(str_gen());
-        } else if (is_single_opr(res[ptr])) {
-            toks.push_back(single_opr());
-        } else if (res[ptr]=='.') {
-            toks.push_back(dots());
-        } else if (is_calc_opr(res[ptr])) {
-            toks.push_back(calc_opr());
-        } else if (res[ptr]=='#') {
-            skip_note();
-        } else {
-            err_char();
-        }
-    }
-    toks.push_back({{line, column, line, column, filename}, tok::eof, "<eof>"});
-    res="";
-    return err;
-}
diff --git a/nasal_opcode.h b/nasal_opcode.h
deleted file mode 100644
index 8c5c270..0000000
--- a/nasal_opcode.h
+++ /dev/null
@@ -1,233 +0,0 @@
-#pragma once
-
-#include "nasal.h"
-#include "nasal_builtin.h"
-
-#include <iostream>
-
-enum op_code_type:u8 {
-    op_exit,   // stop the virtual machine
-    op_intg,   // global scope size, set stack top
-    op_intl,   // local scope size
-    op_loadg,  // load global value
-    op_loadl,  // load local value
-    op_loadu,  // load upvalue
-    op_pnum,   // push constant number to the stack
-    op_pnil,   // push constant nil to the stack
-    op_pstr,   // push constant string to the stack
-    op_newv,   // push new vector with initial values from stack
-    op_newh,   // push new hash to the stack
-    op_newf,   // push new function to the stack
-    op_happ,   // hash append
-    op_para,   // normal  parameter
-    op_deft,   // default parameter
-    op_dyn,    // dynamic parameter
-    op_lnot,   // ! logical negation
-    op_usub,   // - negation
-    op_bnot,   // ~ bitwise not static_cast<i32>
-    op_btor,   // | bitwise or
-    op_btxor,  // ^ bitwise xor
-    op_btand,  // & bitwise and
-    op_add,    // +
-    op_sub,    // -
-    op_mul,    // *
-    op_div,    // /
-    op_lnk,    // ~
-    op_addc,   // + const
-    op_subc,   // - const
-    op_mulc,   // * const
-    op_divc,   // / const
-    op_lnkc,   // ~ const
-    op_addeq,  // += maybe pop stack top
-    op_subeq,  // -= maybe pop stack top
-    op_muleq,  // *= maybe pop stack top
-    op_diveq,  // /= maybe pop stack top
-    op_lnkeq,  // ~= maybe pop stack top
-    op_btandeq,// &= maybe pop stack top
-    op_btoreq, // |= maybe pop stack top
-    op_btxoreq,// ^= maybe pop stack top
-    op_addeqc, // += const don't pop stack top
-    op_subeqc, // -= const don't pop stack top
-    op_muleqc, // *= const don't pop stack top
-    op_diveqc, // /= const don't pop stack top
-    op_lnkeqc, // ~= const don't pop stack top
-    op_addecp, // += const and pop stack top
-    op_subecp, // -= const and pop stack top
-    op_mulecp, // *= const and pop stack top
-    op_divecp, // /= const and pop stack top
-    op_lnkecp, // ~= concat const string and pop stack top
-    op_meq,    // = maybe pop stack top
-    op_eq,     // ==
-    op_neq,    // !=
-    op_less,   // <
-    op_leq,    // <=
-    op_grt,    // >
-    op_geq,    // >=
-    op_lessc,  // < const
-    op_leqc,   // <= const
-    op_grtc,   // > const
-    op_geqc,   // >= const
-    op_pop,    // pop a value out of stack top
-    op_jmp,    // jump absolute address with no condition
-    op_jt,     // used in operator and/or,jmp when condition is true and DO NOT POP
-    op_jf,     // used in conditional/loop,jmp when condition is false and POP STACK
-    op_cnt,    // add counter for forindex/foreach
-    op_findex, // index counter on the top of forindex_stack plus 1
-    op_feach,  // index counter on the top of forindex_stack plus 1 and get the value in vector
-    op_callg,  // get value in global scope
-    op_calll,  // get value in local scope
-    op_upval,  // get value in closure, high 16 as the index of upval, low 16 as the index of local
-    op_callv,  // call vec[index]
-    op_callvi, // call vec[immediate] (used in multi-assign/multi-define)
-    op_callh,  // call hash.label
-    op_callfv, // call function(vector as parameters)
-    op_callfh, // call function(hash as parameters)
-    op_callb,  // call builtin-function
-    op_slcbeg, // begin of slice like: vec[1,2,3:6,0,-1]
-    op_slcend, // end of slice
-    op_slc,    // slice like vec[1]
-    op_slc2,   // slice like vec[nil:10]
-    op_mcallg, // get memory space of value in global scope
-    op_mcalll, // get memory space of value in local scope
-    op_mupval, // get memory space of value in closure
-    op_mcallv, // get memory space of vec[index]
-    op_mcallh, // get memory space of hash.label
-    op_ret     // return
-};
-
-const char* opname[]={
-    "exit  ","intg  ","intl  ","loadg ",
-    "loadl ","loadu ","pnum  ","pnil  ",
-    "pstr  ","newv  ","newh  ","newf  ",
-    "happ  ","para  ","def   ","dyn   ",
-    "lnot  ","usub  ","bnot  ","btor  ",
-    "btxor ","btand ","add   ","sub   ",
-    "mult  ","div   ","lnk   ","addc  ",
-    "subc  ","multc ","divc  ","lnkc  ",
-    "addeq ","subeq ","muleq ","diveq ",
-    "lnkeq ","bandeq","boreq ","bxoreq",
-    "addeqc","subeqc","muleqc","diveqc",
-    "lnkeqc","addecp","subecp","mulecp",
-    "divecp","lnkecp","meq   ","eq    ",
-    "neq   ","less  ","leq   ","grt   ",
-    "geq   ","lessc ","leqc  ","grtc  ",
-    "geqc  ","pop   ","jmp   ","jt    ",
-    "jf    ","cnt   ","findx ","feach ",
-    "callg ","calll ","upval ","callv ",
-    "callvi","callh ","callfv","callfh",
-    "callb ","slcbeg","slcend","slc   ",
-    "slc2  ","mcallg","mcalll","mupval",
-    "mcallv","mcallh","ret   "
-};
-
-struct opcode {
-    u8  op;   // opcode
-    u16 fidx; // source code file index
-    u32 num;  // immediate num
-    u32 line; // location line of source code
-    opcode() = default;
-    opcode(const opcode&) = default;
-    opcode& operator=(const opcode&) = default;
-};
-
-class codestream {
-private:
-    opcode code;
-    const u32 index;
-    static const f64* nums;
-    static const string* strs;
-    static const string* files;
-public:
-    codestream(const opcode& c, const u32 i): code(c), index(i) {}
-    static void set(const f64*, const string*, const string*);
-    void dump(std::ostream&) const;
-};
-
-const f64* codestream::nums=nullptr;
-const string* codestream::strs=nullptr;
-const string* codestream::files=nullptr;
-
-void codestream::set(
-    const f64* numbuff,
-    const string* strbuff,
-    const string* filelist=nullptr
-) {
-    nums=numbuff;
-    strs=strbuff;
-    files=filelist;
-}
-
-void codestream::dump(std::ostream& out) const {
-    using std::setw;
-    using std::setfill;
-    using std::hex;
-    using std::dec;
-    auto op=code.op;
-    auto num=code.num;
-    out<<hex<<"0x"
-        <<setw(6)<<setfill('0')<<index<<"     "
-        <<setw(2)<<setfill('0')<<(u32)op<<" "
-        <<setw(2)<<setfill('0')<<((num>>16)&0xff)<<" "
-        <<setw(2)<<setfill('0')<<((num>>8)&0xff)<<" "
-        <<setw(2)<<setfill('0')<<(num&0xff)<<"     "
-        <<opname[op]<<"  "<<dec;
-    switch(op) {
-        case op_addeq: case op_subeq:
-        case op_muleq: case op_diveq:
-        case op_lnkeq: case op_meq:
-        case op_btandeq: case op_btoreq:
-        case op_btxoreq:
-            out<<hex<<"0x"<<num<<dec<<" sp-"<<num;break;
-        case op_addeqc: case op_subeqc:
-        case op_muleqc:case op_diveqc:
-            out<<hex<<"0x"<<num<<dec<<" ("<<nums[num]<<")";break;
-        case op_lnkeqc:
-            out<<hex<<"0x"<<num<<dec<<" ("<<rawstr(strs[num], 16)<<")";break;
-        case op_addecp: case op_subecp:
-        case op_mulecp: case op_divecp:
-            out<<hex<<"0x"<<num<<dec<<" ("<<nums[num]<<") sp-1";break;
-        case op_lnkecp:
-            out<<hex<<"0x"<<num<<dec<<" ("<<rawstr(strs[num], 16)<<") sp-1";break;
-        case op_addc: case op_subc:
-        case op_mulc: case op_divc:
-        case op_lessc: case op_leqc:
-        case op_grtc: case op_geqc:
-        case op_pnum:
-            out<<hex<<"0x"<<num<<dec<<" ("<<nums[num]<<")";break;
-        case op_callvi: case op_newv:
-        case op_callfv: case op_intg:
-        case op_intl: case op_findex:
-        case op_feach: case op_newf:
-        case op_jmp: case op_jt:
-        case op_jf: case op_callg:
-        case op_mcallg: case op_loadg:
-        case op_calll: case op_mcalll:
-        case op_loadl:
-            out<<hex<<"0x"<<num<<dec;break;
-        case op_callb:
-            out<<hex<<"0x"<<num<<" <"<<builtin[num].name
-                <<"@0x"<<(u64)builtin[num].func<<dec<<">";break;
-        case op_upval: case op_mupval:
-        case op_loadu:
-            out<<hex<<"0x"<<((num>>16)&0xffff)
-                <<"[0x"<<(num&0xffff)<<"]"<<dec;break;
-        case op_happ: case op_pstr:
-        case op_lnkc: case op_callh:
-        case op_mcallh: case op_para:
-        case op_deft: case op_dyn:
-            out<<hex<<"0x"<<num<<dec<<" ("<<rawstr(strs[num], 16)<<")";break;
-        default:
-            if (files) {
-                out<<hex<<"0x"<<num<<dec;
-            }
-            break;
-    }
-    if (files) {
-        out<<"("<<files[code.fidx]<<":"<<code.line<<")";
-    }
-}
-
-std::ostream& operator<<(std::ostream& out, const codestream& ins) {
-    ins.dump(out);
-    return out;
-}
\ No newline at end of file
diff --git a/nasal_opt.h b/nasal_opt.h
deleted file mode 100644
index 7ff9cd8..0000000
--- a/nasal_opt.h
+++ /dev/null
@@ -1,75 +0,0 @@
-#pragma once
-
-#include <cmath>
-
-#include "nasal_ast.h"
-
-void const_str(ast& root) {
-    auto& vec=root.child();
-    root.set_str(vec[0].str()+vec[1].str());
-    root.child().clear();
-    root.set_type(ast_str);
-}
-
-void const_num(ast& root) {
-    auto& vec=root.child();
-    f64 res=0;
-    switch(root.type()) {
-        case ast_add:    res=vec[0].num()+vec[1].num(); break;
-        case ast_sub:    res=vec[0].num()-vec[1].num(); break;
-        case ast_mult:   res=vec[0].num()*vec[1].num(); break;
-        case ast_div:    res=vec[0].num()/vec[1].num(); break;
-        case ast_less:   res=vec[0].num()<vec[1].num(); break;
-        case ast_leq:    res=vec[0].num()<=vec[1].num();break;
-        case ast_grt:    res=vec[0].num()>vec[1].num(); break;
-        case ast_geq:    res=vec[0].num()>=vec[1].num();break;
-        case ast_bitor:  res=i32(vec[0].num())|i32(vec[1].num()); break;
-        case ast_bitxor: res=i32(vec[0].num())^i32(vec[1].num()); break;
-        case ast_bitand: res=i32(vec[0].num())&i32(vec[1].num()); break;
-    }
-    // inf and nan will cause number hashmap error in codegen
-    if (std::isinf(res) || std::isnan(res)) {
-        return;
-    }
-    root.set_num(res);
-    root.child().clear();
-    root.set_type(ast_num);
-}
-
-void calc_const(ast& root) {
-    auto& vec=root.child();
-    for(auto& i:vec) {
-        calc_const(i);
-    }
-    if (vec.size()==1 && root.type()==ast_neg && vec[0].type()==ast_num) {
-        f64 res=-vec[0].num();
-        root.set_num(res);
-        root.child().clear();
-        root.set_type(ast_num);
-        return;
-    }
-    if (vec.size()!=2) {
-        return;
-    }
-    if (root.type()!=ast_add && root.type()!=ast_sub &&
-       root.type()!=ast_mult && root.type()!=ast_div &&
-       root.type()!=ast_link && root.type()!=ast_less &&
-       root.type()!=ast_leq && root.type()!=ast_grt &&
-       root.type()!=ast_geq && root.type()!=ast_bitor &&
-       root.type()!=ast_bitxor && root.type()!=ast_bitand) {
-        return;
-    }
-    if (root.type()==ast_link &&
-       vec[0].type()==ast_str && vec[1].type()==ast_str) {
-        const_str(root);
-    } else if (root.type()!=ast_link &&
-            vec[0].type()==ast_num && vec[1].type()==ast_num) {
-        const_num(root);
-    }
-}
-
-void optimize(ast& root) {
-    for(auto& i:root.child()) {
-        calc_const(i);
-    }
-}
diff --git a/nasal_parse.h b/nasal_parse.h
deleted file mode 100644
index d79e165..0000000
--- a/nasal_parse.h
+++ /dev/null
@@ -1,1111 +0,0 @@
-#pragma once
-
-#include <unordered_map>
-
-#include "nasal.h"
-#include "nasal_lexer.h"
-#include "nasal_ast.h"
-#include "nasal_err.h"
-
-/*
-              _,,,_                                       
-            .'     `'.                                    
-           /     ____ \      Fucking Nasal Parser
-           |  .-'_  _\/    /                              
-           \_/   a  a|    /                               
-           (,`     \ |         .----.                     
-            |     -' |        /|     '--.                 
-             \   '=  /        ||    ]|   `-.              
-             /`-.__.'         ||    ]|    ::|             
-          .-'`-.__ \__        ||    ]|    ::|             
-         /        ``  `.      ||    ]|    ::|             
-       _ |     \     \  \     \|    ]|   .-'              
-      / \|      \    |   \     L.__  .--'(                
-     |   |\      `.  |    \  ,---|_      \---------,      
-     |   | '.      './\    \/ .--._|=-    |_      /|      
-     |   \   '.     `'.'. /`\/ .-'          '.   / |      
-     |   |     `'.     `;-:-;`)|             |-./  |      
-     |   /_       `'--./_  ` )/'-------------')/)  |      
-     \   | `""""----"`\//`""`/,===..'`````````/ (  |      
-      |  |            / `---` `==='          /   ) |      
-      /  \           /                      /   (  |      
-     |    '------.  |'--------------------'|     ) |      
-      \           `-|                      |    /  |      
-       `--...,______|                      |   (   |      
-              | |   |                      |    ) ,|      
-              | |   |                      |   ( /||      
-              | |   |                      |   )/ `"      
-             /   \  |                      |  (/          
-           .' /I\ '.|                      |  /)          
-        .-'_.'/ \'. |                      | /            
-        ```  `"""` `| .-------------------.||             
-                    `"`                   `"`             
-*/
-
-class parse {
-#define thisspan (toks[ptr].loc)
-#define prevspan (ptr!=0? toks[ptr-1].loc:toks[ptr].loc)
-private:
-    u32 ptr;
-    u32 in_func; // count function block
-    u32 in_loop; // count loop block
-    const token* toks;
-    ast root;
-    error& err;
-    const std::unordered_map<tok,string> tokname {
-        {tok::rfor    ,"for"     },
-        {tok::forindex,"forindex"},
-        {tok::foreach ,"foreach" },
-        {tok::rwhile  ,"while"   },
-        {tok::var     ,"var"     },
-        {tok::func    ,"func"    },
-        {tok::brk     ,"break"   },
-        {tok::cont    ,"continue"},
-        {tok::ret     ,"return"  },
-        {tok::rif     ,"if"      },
-        {tok::elsif   ,"elsif"   },
-        {tok::relse   ,"else"    },
-        {tok::tknil   ,"nil"     },
-        {tok::lcurve  ,"("       },
-        {tok::rcurve  ,")"       },
-        {tok::lbracket,"["       },
-        {tok::rbracket,"]"       },
-        {tok::lbrace  ,"{"       },
-        {tok::rbrace  ,"}"       },
-        {tok::semi    ,";"       },
-        {tok::opand   ,"and"     },
-        {tok::opor    ,"or"      },
-        {tok::comma   ,","       },
-        {tok::dot     ,"."       },
-        {tok::ellipsis,"..."     },
-        {tok::quesmark,"?"       },
-        {tok::colon   ,":"       },
-        {tok::add     ,"+"       },
-        {tok::sub     ,"-"       },
-        {tok::mult    ,"*"       },
-        {tok::div     ,"/"       },
-        {tok::floater ,"~"       },
-        {tok::btand   ,"&"       },
-        {tok::btor    ,"|"       },
-        {tok::btxor   ,"^"       },
-        {tok::opnot   ,"!"       },
-        {tok::eq      ,"="       },
-        {tok::addeq   ,"+="      },
-        {tok::subeq   ,"-="      },
-        {tok::multeq  ,"*="      },
-        {tok::diveq   ,"/="      },
-        {tok::lnkeq   ,"~="      },
-        {tok::btandeq ,"&="      },
-        {tok::btoreq  ,"|="      },
-        {tok::btxoreq ,"^="      },
-        {tok::cmpeq   ,"=="      },
-        {tok::neq     ,"!="      },
-        {tok::less    ,"<"       },
-        {tok::leq     ,"<="      },
-        {tok::grt     ,">"       },
-        {tok::geq     ,">="      }
-    };
-
-    void die(const span&,string);
-    void next() {++ptr;}
-    void match(tok type, const char* info=nullptr);
-    bool lookahead(tok);
-    bool is_call(tok);
-    bool check_comma(const tok*);
-    bool check_tuple();
-    bool check_func_end(const ast&);
-    bool check_special_call();
-    bool need_semi_check(const ast&);
-    ast null();
-    ast nil();
-    ast num();
-    ast str();
-    ast id();
-    ast bools();
-    ast vec();
-    ast hash();
-    ast pair();
-    ast func();
-    ast params();
-    ast lcurve_expr();
-    ast expr();
-    ast exprs();
-    ast calc();
-    ast bitwise_or();
-    ast bitwise_xor();
-    ast bitwise_and();
-    ast or_expr();
-    ast and_expr();
-    ast cmp_expr();
-    ast additive_expr();
-    ast multive_expr();
-    ast unary();
-    ast scalar();
-    ast call_scalar();
-    ast callh();
-    ast callv();
-    ast callf();
-    ast subvec();
-    ast definition();
-    ast incurve_def();
-    ast outcurve_def();
-    ast multi_id();
-    ast multi_scalar();
-    ast multi_assign();
-    ast loop();
-    ast while_loop();
-    ast for_loop();
-    ast forei_loop();
-    ast iter_gen();
-    ast cond();
-    ast continue_expr();
-    ast break_expr();
-    ast ret_expr();
-public:
-    parse(error& e):
-        ptr(0), in_func(0), in_loop(0),
-        toks(nullptr),
-        root({0, 0, 0, 0, ""}, ast_root),
-        err(e) {}
-    const error& compile(const lexer&);
-    ast& tree() {return root;}
-    const ast& tree() const {return root;}
-};
-
-const error& parse::compile(const lexer& lexer) {
-    toks=lexer.result().data();
-    ptr=in_func=in_loop=0;
-
-    root={toks[0].loc, ast_root};
-    while(!lookahead(tok::eof)) {
-        root.add(expr());
-        if (lookahead(tok::semi)) {
-            match(tok::semi);
-        } else if (need_semi_check(root.child().back()) && !lookahead(tok::eof)) {
-            // the last expression can be recognized without semi
-            die(prevspan, "expected \";\"");
-        }
-    }
-    root.update_span();
-    return err;
-}
-
-void parse::die(const span& loc, string info) {
-    err.err("parse", loc, info);
-}
-
-void parse::match(tok type,const char* info) {
-    if (!lookahead(type)) {
-        if (info) {
-            die(thisspan, info);
-            return;
-        }
-        switch(type) {
-            case tok::num:die(thisspan, "expected number");    break;
-            case tok::str:die(thisspan, "expected string");    break;
-            case tok::id: die(thisspan, "expected identifier");break;
-            default:      die(thisspan, "expected '"+tokname.at(type)+"'"); break;
-        }
-        return;
-    }
-    if (lookahead(tok::eof)) {
-        return;
-    }
-    next();
-}
-
-bool parse::lookahead(tok type) {
-    return toks[ptr].type==type;
-}
-
-bool parse::is_call(tok type) {
-    return type==tok::lcurve || type==tok::lbracket || type==tok::dot;
-}
-
-bool parse::check_comma(const tok* panic_set) {
-    for(u32 i=0;panic_set[i]!=tok::null;++i) {
-        if (lookahead(panic_set[i])) {
-            die(prevspan, "expected ',' between scalars");
-            return true;
-        }
-    }
-    return false;
-}
-
-bool parse::check_tuple() {
-    u32 check_ptr=ptr, curve=1, bracket=0, brace=0;
-    while(toks[++check_ptr].type!=tok::eof && curve) {
-        switch(toks[check_ptr].type) {
-            case tok::lcurve:   ++curve;   break;
-            case tok::lbracket: ++bracket; break;
-            case tok::lbrace:   ++brace;   break;
-            case tok::rcurve:   --curve;   break;
-            case tok::rbracket: --bracket; break;
-            case tok::rbrace:   --brace;   break;
-            default: break;
-        }
-        if (curve==1 && !bracket && !brace && toks[check_ptr].type==tok::comma) {
-            return true;
-        }
-    }
-    return false;
-}
-
-bool parse::check_func_end(const ast& node) {
-    u32 type=node.type();
-    if (type==ast_func) {
-        return true;
-    } else if (type==ast_num || type==ast_id || type==ast_str || type==ast_nil || type==ast_vec || type==ast_hash) {
-        return false;
-    }
-    if (node.child().empty() || (
-            type!=ast_def &&
-            type!=ast_equal &&
-            type!=ast_addeq &&
-            type!=ast_subeq &&
-            type!=ast_multeq &&
-            type!=ast_diveq &&
-            type!=ast_lnkeq
-        )
-    ) {
-        return false;
-    } else {
-        return check_func_end(node.child().back());
-    }
-    return false;
-}
-
-bool parse::check_special_call() {
-    // special call means like this: function_name(a:1,b:2,c:3);
-    u32 check_ptr=ptr, curve=1, bracket=0, brace=0;
-    while(toks[++check_ptr].type!=tok::eof && curve) {
-        switch(toks[check_ptr].type) {
-            case tok::lcurve:   ++curve;  break;
-            case tok::lbracket: ++bracket;break;
-            case tok::lbrace:   ++brace;  break;
-            case tok::rcurve:   --curve;  break;
-            case tok::rbracket: --bracket;break;
-            case tok::rbrace:   --brace;  break;
-            default: break;
-        }
-        // m?1:0 will be recognized as normal parameter
-        if (curve==1 && !bracket && !brace && toks[check_ptr].type==tok::quesmark) {
-            return false;
-        }
-        if (curve==1 && !bracket && !brace && toks[check_ptr].type==tok::colon) {
-            return true;
-        }
-    }
-    return false;
-}
-
-bool parse::need_semi_check(const ast& node) {
-    u32 type=node.type();
-    if (type==ast_for || type==ast_foreach || type==ast_forindex || type==ast_while || type==ast_cond) {
-        return false;
-    }
-    return !check_func_end(node);
-}
-
-ast parse::null() {
-    return {toks[ptr].loc, ast_null};
-}
-
-ast parse::nil() {
-    return {toks[ptr].loc, ast_nil};
-}
-
-ast parse::num() {
-    ast node(toks[ptr].loc, ast_num);
-    node.set_num(str2num(toks[ptr].str.c_str()));
-    match(tok::num);
-    return node;
-}
-
-ast parse::str() {
-    ast node(toks[ptr].loc, ast_str);
-    node.set_str(toks[ptr].str);
-    match(tok::str);
-    return node;
-}
-
-ast parse::id() {
-    ast node(toks[ptr].loc, ast_id);
-    node.set_str(toks[ptr].str);
-    match(tok::id);
-    return node;
-}
-
-ast parse::bools() {
-    ast node(toks[ptr].loc, ast_bool);
-    node.set_str(toks[ptr].str);
-    if (lookahead(tok::tktrue)) {
-        match(tok::tktrue);
-    } else {
-        match(tok::tkfalse);
-    }
-    return node;
-}
-
-ast parse::vec() {
-    // panic set for this token is not ','
-    // this is the FIRST set of calculation
-    // array end with tok::null=0
-    const tok panic[]={
-        tok::id,tok::str,tok::num,tok::tktrue,
-        tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
-        tok::func,tok::var,tok::lcurve,tok::floater,
-        tok::lbrace,tok::lbracket,tok::null
-    };
-    ast node(toks[ptr].loc, ast_vec);
-    match(tok::lbracket);
-    while(!lookahead(tok::rbracket)) {
-        node.add(calc());
-        if (lookahead(tok::comma)) {
-            match(tok::comma);
-        } else if (lookahead(tok::eof)) {
-            break;
-        } else if (!lookahead(tok::rbracket) && !check_comma(panic)) {
-            break;
-        }
-    }
-    node.update_span(thisspan);
-    match(tok::rbracket, "expected ']' when generating vector");
-    return node;
-}
-
-ast parse::hash() {
-    ast node(toks[ptr].loc, ast_hash);
-    match(tok::lbrace);
-    while(!lookahead(tok::rbrace)) {
-        node.add(pair());
-        if (lookahead(tok::comma)) {
-            match(tok::comma);
-        } else if (lookahead(tok::id) || lookahead(tok::str)) { // first set of hashmember
-            die(prevspan, "expected ',' between hash members");
-        } else {
-            break;
-        }
-    }
-    node.update_span(thisspan);
-    match(tok::rbrace, "expected '}' when generating hash");
-    return node;
-}
-
-ast parse::pair() {
-    ast node(toks[ptr].loc, ast_pair);
-    if (lookahead(tok::id)) {
-        node.add(id());
-    } else if (lookahead(tok::str)) {
-        node.add(str());
-    } else {
-        match(tok::id, "expected hashmap key");
-    }
-    match(tok::colon);
-    node.add(calc());
-    node.update_span();
-    return node;
-}
-
-ast parse::func() {
-    ++in_func;
-    ast node(toks[ptr].loc, ast_func);
-    match(tok::func);
-    if (lookahead(tok::lcurve)) {
-        node.add(params());
-    } else {
-        node.add(null());
-    }
-    node.add(exprs());
-    --in_func;
-    node.update_span();
-    return node;
-}
-
-ast parse::params() {
-    ast node(toks[ptr].loc, ast_params);
-    match(tok::lcurve);
-    while(!lookahead(tok::rcurve)) {
-        ast tmp=id();
-        if (lookahead(tok::eq) || lookahead(tok::ellipsis)) {
-            ast special_arg(toks[ptr].loc, ast_null);
-            if (lookahead(tok::eq)) {
-                match(tok::eq);
-                special_arg=std::move(tmp);
-                special_arg.set_type(ast_default);
-                special_arg.add(calc());
-            } else {
-                match(tok::ellipsis);
-                special_arg=std::move(tmp);
-                special_arg.set_type(ast_dynamic);
-            }
-            node.add(std::move(special_arg));
-        } else {
-            node.add(std::move(tmp));
-        }
-        if (lookahead(tok::comma)) {
-            match(tok::comma);
-        } else if (lookahead(tok::id)) { // first set of identifier
-            die(prevspan, "expected ',' between identifiers");
-        } else {
-            break;
-        }
-    }
-    node.update_span(thisspan);
-    match(tok::rcurve, "expected ')' after parameter list");
-    return node;
-}
-
-ast parse::lcurve_expr() {
-    if (toks[ptr+1].type==tok::var)
-        return definition();
-    return check_tuple()?multi_assign():calc();
-}
-
-ast parse::expr() {
-    tok type=toks[ptr].type;
-    if ((type==tok::brk || type==tok::cont) && !in_loop) {
-        die(thisspan, "must use break/continue in loops");
-    }
-    if (type==tok::ret && !in_func) {
-        die(thisspan, "must use return in functions");
-    }
-    switch(type) {
-        case tok::tknil:
-        case tok::num:
-        case tok::str:
-        case tok::id:
-        case tok::tktrue:
-        case tok::tkfalse:
-        case tok::func:
-        case tok::lbracket:
-        case tok::lbrace:
-        case tok::sub:
-        case tok::floater:
-        case tok::opnot:   return calc();          break;
-        case tok::var:     return definition();    break;
-        case tok::lcurve:  return lcurve_expr();   break;
-        case tok::rfor:
-        case tok::forindex:
-        case tok::foreach:
-        case tok::rwhile:  return loop();          break;
-        case tok::rif:     return cond();          break;
-        case tok::cont:    return continue_expr(); break;
-        case tok::brk:     return break_expr();    break;
-        case tok::ret:     return ret_expr();      break;
-        case tok::semi:                            break;
-        default:
-            die(thisspan, "incorrect token <"+toks[ptr].str+">");
-            next();
-            break;
-    }
-
-    // unreachable
-    return {toks[ptr].loc, ast_null};
-}
-
-ast parse::exprs() {
-    if (lookahead(tok::eof)) {
-        die(thisspan, "expected expression block");
-        return null();
-    }
-    ast node(toks[ptr].loc, ast_block);
-    if (lookahead(tok::lbrace)) {
-        match(tok::lbrace);
-        while(!lookahead(tok::rbrace) && !lookahead(tok::eof)) {
-            node.add(expr());
-            if (lookahead(tok::semi)) {
-                match(tok::semi);
-            } else if (need_semi_check(node.child().back()) && !lookahead(tok::rbrace)) {
-                // the last expression can be recognized without semi
-                die(prevspan, "expected ';'");
-            }
-        }
-        match(tok::rbrace, "expected '}' when generating expressions");
-    } else {
-        node.add(expr());
-        if (lookahead(tok::semi))
-            match(tok::semi);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::calc() {
-    ast node=bitwise_or();
-    if (lookahead(tok::quesmark)) {
-        // trinocular calculation
-        ast tmp(toks[ptr].loc, ast_trino);
-        match(tok::quesmark);
-        tmp.add(std::move(node));
-        tmp.add(calc());
-        match(tok::colon);
-        tmp.add(calc());
-        node=std::move(tmp);
-    } else if (tok::eq<=toks[ptr].type && toks[ptr].type<=tok::lnkeq) {
-        // tok::eq~tok::lnkeq is 37 to 42,ast_equal~ast_lnkeq is 21~26
-        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::eq+ast_equal);
-        tmp.add(std::move(node));
-        match(toks[ptr].type);
-        tmp.add(calc());
-        node=std::move(tmp);
-    } else if (toks[ptr].type==tok::btandeq || toks[ptr].type==tok::btoreq || toks[ptr].type==tok::btxoreq) {
-        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::btandeq+ast_btandeq);
-        tmp.add(std::move(node));
-        match(toks[ptr].type);
-        tmp.add(calc());
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::bitwise_or() {
-    ast node=bitwise_xor();
-    while(lookahead(tok::btor)) {
-        ast tmp(toks[ptr].loc, ast_bitor);
-        tmp.add(std::move(node));
-        match(tok::btor);
-        tmp.add(bitwise_xor());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::bitwise_xor() {
-    ast node=bitwise_and();
-    while(lookahead(tok::btxor)) {
-        ast tmp(toks[ptr].loc, ast_bitxor);
-        tmp.add(std::move(node));
-        match(tok::btxor);
-        tmp.add(bitwise_and());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::bitwise_and() {
-    ast node=or_expr();
-    while(lookahead(tok::btand)) {
-        ast tmp(toks[ptr].loc, ast_bitand);
-        tmp.add(std::move(node));
-        match(tok::btand);
-        tmp.add(or_expr());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::or_expr() {
-    ast node=and_expr();
-    while(lookahead(tok::opor)) {
-        ast tmp(toks[ptr].loc, ast_or);
-        tmp.add(std::move(node));
-        match(tok::opor);
-        tmp.add(and_expr());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::and_expr() {
-    ast node=cmp_expr();
-    while(lookahead(tok::opand)) {
-        ast tmp(toks[ptr].loc, ast_and);
-        tmp.add(std::move(node));
-        match(tok::opand);
-        tmp.add(cmp_expr());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::cmp_expr() {
-    ast node=additive_expr();
-    while(tok::cmpeq<=toks[ptr].type && toks[ptr].type<=tok::geq) {
-        // tok::cmpeq~tok::geq is 43~48,ast_cmpeq~ast_geq is 27~32
-        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::cmpeq+ast_cmpeq);
-        tmp.add(std::move(node));
-        match(toks[ptr].type);
-        tmp.add(additive_expr());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::additive_expr() {
-    ast node=multive_expr();
-    while(lookahead(tok::add) || lookahead(tok::sub) || lookahead(tok::floater)) {
-        ast tmp(toks[ptr].loc, ast_null);
-        switch(toks[ptr].type) {
-            case tok::add: tmp.set_type(ast_add);  break;
-            case tok::sub: tmp.set_type(ast_sub);  break;
-            case tok::floater: tmp.set_type(ast_link); break;
-            default: break;
-        }
-        tmp.add(std::move(node));
-        match(toks[ptr].type);
-        tmp.add(multive_expr());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::multive_expr() {
-    ast node=(lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar();
-    while(lookahead(tok::mult) || lookahead(tok::div)) {
-        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::mult+ast_mult);
-        tmp.add(std::move(node));
-        match(toks[ptr].type);
-        tmp.add((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::unary() {
-    ast node(toks[ptr].loc,ast_null);
-    switch(toks[ptr].type) {
-        case tok::sub:     node.set_type(ast_neg);match(tok::sub);break;
-        case tok::opnot:   node.set_type(ast_lnot);match(tok::opnot);break;
-        case tok::floater: node.set_type(ast_bnot);match(tok::floater);break;
-        default: break;
-    }
-    node.add((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
-    node.update_span();
-    return node;
-}
-
-ast parse::scalar() {
-    ast node(toks[ptr].loc, ast_null);
-    if (lookahead(tok::tknil)) {
-        node=nil();
-        match(tok::tknil);
-    } else if (lookahead(tok::num)) {
-        node=num();
-    } else if (lookahead(tok::str)) {
-        node=str();
-    } else if (lookahead(tok::id)) {
-        node=id();
-    } else if (lookahead(tok::tktrue) || lookahead(tok::tkfalse)) {
-        node=bools();
-    } else if (lookahead(tok::func)) {
-        node=func();
-    } else if (lookahead(tok::lbracket)) {
-        node=vec();
-    } else if (lookahead(tok::lbrace)) {
-        node=hash();
-    } else if (lookahead(tok::lcurve)) {
-        const auto& loc=toks[ptr].loc;
-        match(tok::lcurve);
-        node=calc();
-        node.set_begin(loc.begin_line, loc.begin_column);
-        node.update_span(thisspan);
-        match(tok::rcurve);
-    } else if (lookahead(tok::var)) {
-        match(tok::var);
-        node.set_type(ast_def);
-        node.add(id());
-        match(tok::eq);
-        node.add(calc());
-    } else {
-        die(thisspan, "expected scalar");
-        return node;
-    }
-    // check call and avoid ambiguous syntax
-    if (is_call(toks[ptr].type) && !(lookahead(tok::lcurve) && toks[ptr+1].type==tok::var)) {
-        ast tmp=std::move(node);
-        node={toks[ptr].loc, ast_call};
-        node.add(std::move(tmp));
-        while(is_call(toks[ptr].type)) {
-            node.add(call_scalar());
-        }
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::call_scalar() {
-    switch(toks[ptr].type) {
-        case tok::lcurve:   return callf(); break;
-        case tok::lbracket: return callv(); break;
-        case tok::dot:      return callh(); break;
-        default: break;
-    }
-    // unreachable
-    return {toks[ptr].loc, ast_nil};
-}
-
-ast parse::callh() {
-    ast node(toks[ptr].loc, ast_callh);
-    match(tok::dot);
-    node.set_str(toks[ptr].str);
-    node.set_end(toks[ptr].loc.end_line, toks[ptr].loc.end_column);
-    match(tok::id, "expected hashmap key"); // get key
-    return node;
-}
-
-ast parse::callv() {
-    // panic set for this token is not ','
-    // this is the FIRST set of subvec
-    // array end with tok::null=0
-    const tok panic[]={
-        tok::id,tok::str,tok::num,tok::tktrue,
-        tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
-        tok::func,tok::var,tok::lcurve,tok::floater,
-        tok::lbrace,tok::lbracket,tok::colon,tok::null
-    };
-    ast node(toks[ptr].loc, ast_callv);
-    match(tok::lbracket);
-    while(!lookahead(tok::rbracket)) {
-        node.add(subvec());
-        if (lookahead(tok::comma)) {
-            match(tok::comma);
-        } else if (lookahead(tok::eof)) {
-            break;
-        } else if (!lookahead(tok::rbracket) && !check_comma(panic)) {
-            break;
-        }
-    }
-    if (node.size()==0) {
-        die(thisspan, "expected index value");
-    }
-    node.update_span(thisspan);
-    match(tok::rbracket, "expected ']' when calling vector");
-    return node;
-}
-
-ast parse::callf() {
-    // panic set for this token is not ','
-    // this is the FIRST set of calculation/hashmember
-    // array end with tok::null=0
-    const tok panic[]={
-        tok::id,tok::str,tok::num,tok::tktrue,
-        tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
-        tok::func,tok::var,tok::lcurve,tok::floater,
-        tok::lbrace,tok::lbracket,tok::null
-    };
-    ast node(toks[ptr].loc, ast_callf);
-    bool special_call=check_special_call();
-    match(tok::lcurve);
-    while(!lookahead(tok::rcurve)) {
-        node.add(special_call?pair():calc());
-        if (lookahead(tok::comma))
-            match(tok::comma);
-        else if (lookahead(tok::eof))
-            break;
-        else if (!lookahead(tok::rcurve) && !check_comma(panic))
-            break;
-    }
-    node.update_span(thisspan);
-    match(tok::rcurve, "expected ')' when calling function");
-    return node;
-}
-
-ast parse::subvec() {
-    ast node=lookahead(tok::colon)?nil():calc();
-    if (lookahead(tok::colon)) {
-        ast tmp(toks[ptr].loc, ast_subvec);
-        match(tok::colon);
-        tmp.add(std::move(node));
-        tmp.add((lookahead(tok::comma) || lookahead(tok::rbracket))?nil():calc());
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::definition() {
-    ast node(toks[ptr].loc, ast_def);
-    if (lookahead(tok::var)) {
-        match(tok::var);
-        switch(toks[ptr].type) {
-            case tok::id: node.add(id());break;
-            case tok::lcurve: node.add(outcurve_def());break;
-            default: die(thisspan, "expected identifier");break;
-        }
-    } else if (lookahead(tok::lcurve)) {
-        node.add(incurve_def());
-    }
-    match(tok::eq);
-    if (lookahead(tok::lcurve)) {
-        node.add(check_tuple()?multi_scalar():calc());
-    } else {
-        node.add(calc());
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::incurve_def() {
-    const auto& loc=toks[ptr].loc;
-    match(tok::lcurve);
-    match(tok::var);
-    ast node=multi_id();
-    node.update_span(thisspan);
-    match(tok::rcurve);
-    node.set_begin(loc.begin_line, loc.begin_column);
-    return node;
-}
-
-ast parse::outcurve_def() {
-    const auto& loc=toks[ptr].loc;
-    match(tok::lcurve);
-    ast node=multi_id();
-    node.update_span(thisspan);
-    match(tok::rcurve);
-    node.set_begin(loc.begin_line, loc.begin_column);
-    return node;
-}
-
-ast parse::multi_id() {
-    ast node(toks[ptr].loc, ast_multi_id);
-    while(!lookahead(tok::eof)) {
-        // only identifier is allowed here
-        // but we check it at codegen stage
-        node.add(calc());
-        if (lookahead(tok::comma)) {
-            match(tok::comma);
-        } else if (lookahead(tok::id)) { // first set of identifier
-            die(prevspan, "expected ',' between identifiers");
-        } else {
-            break;
-        }
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::multi_scalar() {
-    // if check_call_memory is true,we will check if value called here can reach a memory space
-    const tok panic[]={
-        tok::id,tok::str,tok::num,tok::tktrue,
-        tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
-        tok::func,tok::var,tok::lcurve,tok::floater,
-        tok::lbrace,tok::lbracket,tok::null
-    };
-    ast node(toks[ptr].loc, ast_tuple);
-    match(tok::lcurve);
-    while(!lookahead(tok::rcurve)) {
-        node.add(calc());
-        if (lookahead(tok::comma)) {
-            match(tok::comma);
-        } else if (lookahead(tok::eof)) {
-            break;
-        } else if (!lookahead(tok::rcurve) && !check_comma(panic)) {
-            break;
-        }
-    }
-    node.update_span(thisspan);
-    match(tok::rcurve, "expected ')' after multi-scalar");
-    return node;
-}
-
-ast parse::multi_assign() {
-    ast node(toks[ptr].loc, ast_multi_assign);
-    node.add(multi_scalar());
-    match(tok::eq);
-    if (lookahead(tok::eof)) {
-        die(thisspan, "expected value list");
-        return node;
-    }
-    if (lookahead(tok::lcurve)) {
-        node.add(check_tuple()?multi_scalar():calc());
-    } else {
-        node.add(calc());
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::loop() {
-    ++in_loop;
-    ast node(toks[ptr].loc, ast_null);
-    switch(toks[ptr].type) {
-        case tok::rwhile:  node=while_loop(); break;
-        case tok::rfor:    node=for_loop();   break;
-        case tok::forindex:
-        case tok::foreach: node=forei_loop(); break;
-        default: break;
-    }
-    --in_loop;
-    return node;
-}
-
-ast parse::while_loop() {
-    ast node(toks[ptr].loc, ast_while);
-    match(tok::rwhile);
-    match(tok::lcurve);
-    node.add(calc());
-    match(tok::rcurve);
-    node.add(exprs());
-    node.update_span();
-    return node;
-}
-
-ast parse::for_loop() {
-    ast node(toks[ptr].loc, ast_for);
-    match(tok::rfor);
-    match(tok::lcurve);
-    // first expression
-    if (lookahead(tok::eof)) {
-        die(thisspan, "expected definition");
-    }
-    if (lookahead(tok::semi)) {
-        node.add(null());
-    } else if (lookahead(tok::var)) {
-        node.add(definition());
-    } else if (lookahead(tok::lcurve)) {
-        node.add(lcurve_expr());
-    } else {
-        node.add(calc());
-    }
-    match(tok::semi, "expected ';' in for(;;)");
-    // conditional expression
-    if (lookahead(tok::eof)) {
-        die(thisspan, "expected conditional expr");
-    }
-    if (lookahead(tok::semi)) {
-        node.add(null());
-    } else {
-        node.add(calc());
-    }
-    match(tok::semi, "expected ';' in for(;;)");
-    //after loop expression
-    if (lookahead(tok::eof)) {
-        die(thisspan, "expected calculation");
-    }
-    if (lookahead(tok::rcurve)) {
-        node.add(null());
-    } else {
-        node.add(calc());
-    }
-    match(tok::rcurve);
-    node.add(exprs());
-    node.update_span();
-    return node;
-}
-
-ast parse::forei_loop() {
-    ast node(toks[ptr].loc, ast_null);
-    switch(toks[ptr].type) {
-        case tok::forindex:node.set_type(ast_forindex);match(tok::forindex);break;
-        case tok::foreach: node.set_type(ast_foreach); match(tok::foreach); break;
-        default: break;
-    }
-    match(tok::lcurve);
-    // first expression
-    // foreach/forindex must have an iterator to loop through
-    if (!lookahead(tok::var) && !lookahead(tok::id)) {
-        die(thisspan, "expected iterator");
-    }
-    node.add(iter_gen());
-    match(tok::semi, "expected ';' in foreach/forindex(iter;vector)");
-    if (lookahead(tok::eof)) {
-        die(thisspan, "expected vector");
-    }
-    node.add(calc());
-    match(tok::rcurve);
-    node.add(exprs());
-    node.update_span();
-    return node;
-}
-
-ast parse::iter_gen() {
-    ast node(toks[ptr].loc, ast_null);
-    if (lookahead(tok::var)) {
-        match(tok::var);
-        node.set_type(ast_iter);
-        node.add(id());
-    } else {
-        node.set_type(ast_call);
-        node.add(id());
-        while(is_call(toks[ptr].type)) {
-            node.add(call_scalar());
-        }
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::cond() {
-    ast node(toks[ptr].loc, ast_cond);
-
-    // generate if
-    ast ifnode(toks[ptr].loc, ast_if);
-    match(tok::rif);
-    match(tok::lcurve);
-    ifnode.add(calc());
-    match(tok::rcurve);
-    ifnode.add(exprs());
-    ifnode.update_span();
-    node.add(std::move(ifnode));
-
-    // generate elsif
-    while(lookahead(tok::elsif)) {
-        ast elsifnode(toks[ptr].loc, ast_elsif);
-        match(tok::elsif);
-        match(tok::lcurve);
-        elsifnode.add(calc());
-        match(tok::rcurve);
-        elsifnode.add(exprs());
-        elsifnode.update_span();
-        node.add(std::move(elsifnode));
-    }
-
-    // generate else
-    if (lookahead(tok::relse)) {
-        ast elsenode(toks[ptr].loc, ast_else);
-        match(tok::relse);
-        elsenode.add(exprs());
-        elsenode.update_span();
-        node.add(std::move(elsenode));
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::continue_expr() {
-    ast node(toks[ptr].loc, ast_continue);
-    match(tok::cont);
-    return node;
-}
-
-ast parse::break_expr() {
-    ast node(toks[ptr].loc, ast_break);
-    match(tok::brk);
-    return node;
-}
-
-ast parse::ret_expr() {
-    ast node(toks[ptr].loc, ast_ret);
-    match(tok::ret);
-    tok type=toks[ptr].type;
-    if (type==tok::tknil || type==tok::num ||
-        type==tok::str || type==tok::id ||
-        type==tok::func || type==tok::sub ||
-        type==tok::opnot || type==tok::lcurve ||
-        type==tok::lbracket || type==tok::lbrace ||
-        type==tok::tktrue || type==tok::tkfalse
-    ) {
-        node.add(calc());
-    }
-    node.update_span();
-    return node;
-}
diff --git a/nasal_vm.h b/nasal_vm.h
deleted file mode 100644
index 04de83c..0000000
--- a/nasal_vm.h
+++ /dev/null
@@ -1,1287 +0,0 @@
-#pragma once
-
-#include <iomanip>
-#include <stack>
-
-#include "nasal_import.h"
-#include "nasal_gc.h"
-#include "nasal_codegen.h"
-
-#ifdef _MSC_VER
-#pragma warning (disable:4244)
-#pragma warning (disable:4267)
-#pragma warning (disable:4102)
-#endif
-
-class vm {
-protected:
-
-    /* registers and constants of vm */
-    context ctx;
-
-    /* constants */
-    const f64* cnum=nullptr;    // constant numbers
-    const string* cstr=nullptr; // constant symbols and strings
-    std::vector<u32> imm;       // immediate number table
-    
-    /* garbage collector */
-    gc ngc;
-
-    /* main stack */
-    var stack[STACK_DEPTH];
-
-    /* values used for debugger */
-    const string* files=nullptr;    // file name list
-    const opcode* bytecode=nullptr; // bytecode buffer address
-
-    /* vm initializing function */
-    void init(
-        const std::vector<string>&,
-        const std::vector<f64>&,
-        const std::vector<opcode>&,
-        const std::vector<string>&,
-        const std::vector<string>&);
-
-    /* debug functions */
-    bool verbose;
-    void valinfo(var&);
-    void traceback();
-    void stackinfo(const u32);
-    void reginfo();
-    void gstate();
-    void lstate();
-    void ustate();
-    void detail();
-    void die(const string&);
-
-    /* vm calculation functions*/
-    bool cond(var&);
-
-    /* vm operands */
-    void o_intg();
-    void o_intl();
-    void o_loadg();
-    void o_loadl();
-    void o_loadu();
-    void o_pnum();
-    void o_pnil();
-    void o_pstr();
-    void o_newv();
-    void o_newh();
-    void o_newf();
-    void o_happ();
-    void o_para();
-    void o_deft();
-    void o_dyn();
-    void o_lnot();
-    void o_usub();
-    void o_bnot();
-    void o_btor();
-    void o_btxor();
-    void o_btand();
-    void o_add();
-    void o_sub();
-    void o_mul();
-    void o_div();
-    void o_lnk();
-    void o_addc();
-    void o_subc();
-    void o_mulc();
-    void o_divc();
-    void o_lnkc();
-    void o_addeq();
-    void o_subeq();
-    void o_muleq();
-    void o_diveq();
-    void o_lnkeq();
-    void o_bandeq();
-    void o_boreq();
-    void o_bxoreq();
-    void o_addeqc();
-    void o_subeqc();
-    void o_muleqc();
-    void o_diveqc();
-    void o_lnkeqc();
-    void o_addecp();
-    void o_subecp();
-    void o_mulecp();
-    void o_divecp();
-    void o_lnkecp();
-    void o_meq();
-    void o_eq();
-    void o_neq();
-    void o_less();
-    void o_leq();
-    void o_grt();
-    void o_geq();
-    void o_lessc();
-    void o_leqc();
-    void o_grtc();
-    void o_geqc();
-    void o_pop();
-    void o_jmp();
-    void o_jt();
-    void o_jf();
-    void o_cnt();
-    void o_findex();
-    void o_feach();
-    void o_callg();
-    void o_calll();
-    void o_upval();
-    void o_callv();
-    void o_callvi();
-    void o_callh();
-    void o_callfv();
-    void o_callfh();
-    void o_callb();
-    void o_slcbeg();
-    void o_slcend();
-    void o_slc();
-    void o_slc2();
-    void o_mcallg();
-    void o_mcalll();
-    void o_mupval();
-    void o_mcallv();
-    void o_mcallh();
-    void o_ret();
-public:
-
-    /* constructor of vm instance */
-    vm(): ngc(&ctx), verbose(false) {}
-
-    /* execution entry */
-    void run(
-        const codegen&,
-        const linker&,
-        const std::vector<string>&,
-        const bool
-    );
-};
-
-void vm::init(
-    const std::vector<string>& strs,
-    const std::vector<f64>&    nums,
-    const std::vector<opcode>& code,
-    const std::vector<string>& filenames,
-    const std::vector<string>& argv
-) {
-    cnum=nums.data();
-    cstr=strs.data();
-    bytecode=code.data();
-    files=filenames.data();
-
-    /* set canary and program counter */
-    ctx.pc=0;
-    ctx.localr=ctx.memr=nullptr;
-    ctx.funcr=ctx.upvalr=nil;
-    ctx.canary=stack+STACK_DEPTH-1; // stack[STACK_DEPTH-1]
-    ctx.top=stack;
-    ctx.stack=stack;
-
-    /* clear main stack */
-    for(u32 i=0;i<STACK_DEPTH;++i) {
-        stack[i]=nil;
-    }
-
-    /* init gc */
-    ngc.init(strs,argv);
-}
-
-void vm::valinfo(var& val) {
-    const nas_val* p=val.val.gcobj;
-    switch(val.type) {
-        case vm_none: std::clog<<"| null |";break;
-        case vm_ret:  std::clog<<"| pc   | 0x"<<std::hex
-                               <<val.ret()<<std::dec;break;
-        case vm_addr: std::clog<<"| addr | 0x"<<std::hex
-                               <<(u64)val.addr()<<std::dec;break;
-        case vm_cnt:  std::clog<<"| cnt  | "<<val.cnt();break;
-        case vm_nil:  std::clog<<"| nil  |";break;
-        case vm_num:  std::clog<<"| num  | "<<val.num();break;
-        case vm_str:  std::clog<<"| str  | <0x"<<std::hex<<(u64)p
-                               <<"> "<<rawstr(val.str(),16)<<std::dec;break;
-        case vm_func: std::clog<<"| func | <0x"<<std::hex<<(u64)p
-                               <<"> entry:0x"<<val.func().entry
-                               <<std::dec;break;
-        case vm_upval:std::clog<<"| upval| <0x"<<std::hex<<(u64)p
-                               <<std::dec<<"> ["<<val.upval().size
-                               <<" val]";break;
-        case vm_vec:  std::clog<<"| vec  | <0x"<<std::hex<<(u64)p
-                               <<std::dec<<"> ["<<val.vec().size()
-                               <<" val]";break;
-        case vm_hash: std::clog<<"| hash | <0x"<<std::hex<<(u64)p
-                               <<std::dec<<"> {"<<val.hash().size()
-                               <<" val}";break;
-        case vm_obj:  std::clog<<"| obj  | <0x"<<std::hex<<(u64)p
-                               <<"> obj:0x"<<(u64)val.obj().ptr
-                               <<std::dec;break;
-        case vm_co:   std::clog<<"| co   | <0x"<<std::hex<<(u64)p
-                               <<std::dec<<"> coroutine";break;
-        default:      std::clog<<"| err  | <0x"<<std::hex<<(u64)p
-                               <<std::dec<<"> unknown object";break;
-    }
-    std::clog<<"\n";
-}
-
-void vm::traceback() {
-    /* bytecode[0].num is the global size */
-    var* bottom=ngc.rctx->stack==stack?stack+bytecode[0].num:ngc.rctx->stack;
-    var* ctx_top=ngc.rctx->stack==stack?ctx.top:ngc.rctx->top;
-    std::stack<u32> ret;
-    for(var* i=bottom;i<=ctx_top;++i) {
-        if (i->type==vm_ret && i->ret()!=0) {
-            ret.push(i->ret());
-        }
-    }
-    ret.push(ctx.pc); // store the position program crashed
-    std::clog<<"trace back ("<<(ngc.rctx->stack==stack?"main":"coroutine")<<")\n";
-    codestream::set(cnum, cstr, files);
-    for(u32 p=0,same=0,prev=0xffffffff;!ret.empty();prev=p,ret.pop()) {
-        if ((p=ret.top())==prev) {
-            ++same;
-            continue;
-        }
-        if (same) {
-            std::clog
-            <<"  0x"<<std::hex<<std::setw(6)<<std::setfill('0')
-            <<prev<<std::dec<<"     "<<same<<" same call(s)\n";
-        }
-        same=0;
-        std::clog<<"  "<<codestream(bytecode[p],p)<<"\n";
-    }
-    // the first called place has no same calls
-}
-
-void vm::stackinfo(const u32 limit=10) {
-    /* bytecode[0].num is the global size */
-    const u32 gsize=ngc.rctx->stack==stack?bytecode[0].num:0;
-    var* t=ctx.top;
-    var* bottom=ngc.rctx->stack+gsize;
-    std::clog<<"stack (0x"<<std::hex<<(u64)bottom<<std::dec
-             <<" <+"<<gsize<<">, limit "<<limit<<", total "
-             <<(t<bottom? 0:(i64)(t-bottom+1))<<")\n";
-    for(u32 i=0;i<limit && t>=bottom;++i,--t) {
-        std::clog<<"  0x"<<std::hex
-                 <<std::setw(6)<<std::setfill('0')
-                 <<(u64)(t-ngc.rctx->stack)<<std::dec
-                 <<"    ";
-        valinfo(t[0]);
-    }
-}
-
-void vm::reginfo() {
-    std::clog<<"registers ("<<(ngc.cort?"coroutine":"main")<<")\n"<<std::hex
-             <<"  [pc    ]    | pc   | 0x"<<ctx.pc<<"\n"
-             <<"  [global]    | addr | 0x"<<(u64)stack<<"\n"
-             <<"  [local ]    | addr | 0x"<<(u64)ctx.localr<<"\n"
-             <<"  [memr  ]    | addr | 0x"<<(u64)ctx.memr<<"\n"
-             <<"  [canary]    | addr | 0x"<<(u64)ctx.canary<<"\n"
-             <<"  [top   ]    | addr | 0x"<<(u64)ctx.top<<"\n"
-             <<std::dec;
-    std::clog<<"  [funcr ]    ";valinfo(ctx.funcr);
-    std::clog<<"  [upval ]    ";valinfo(ctx.upvalr);
-}
-
-void vm::gstate() {
-    if (!bytecode[0].num || stack[0].type==vm_none) { // bytecode[0].op is op_intg
-        return;
-    }
-    std::clog<<"global (0x"<<std::hex<<(u64)stack<<" <+0>)\n"<<std::dec;
-    for(u32 i=0;i<bytecode[0].num;++i) {
-        std::clog<<"  0x"<<std::hex<<std::setw(6)
-                 <<std::setfill('0')<<i<<std::dec
-                 <<"    ";
-        valinfo(stack[i]);
-    }
-}
-
-void vm::lstate() {
-    if (!ctx.localr || !ctx.funcr.func().lsize) {
-        return;
-    }
-    const u32 lsize=ctx.funcr.func().lsize;
-    std::clog<<"local (0x"<<std::hex<<(u64)ctx.localr
-             <<" <+"<<(u64)(ctx.localr-ngc.rctx->stack)<<">)\n"<<std::dec;
-    for(u32 i=0;i<lsize;++i) {
-        std::clog<<"  0x"<<std::hex<<std::setw(6)
-                 <<std::setfill('0')<<i<<std::dec
-                 <<"    ";
-        valinfo(ctx.localr[i]);
-    }
-}
-
-void vm::ustate() {
-    if (ctx.funcr.type==vm_nil || ctx.funcr.func().upval.empty()) {
-        return;
-    }
-    std::clog<<"upvalue\n";
-    auto& upval=ctx.funcr.func().upval;
-    for(u32 i=0;i<upval.size();++i) {
-        std::clog<<"  -> upval["<<i<<"]:\n";
-        auto& uv=upval[i].upval();
-        for(u32 j=0;j<uv.size;++j) {
-            std::clog<<"     0x"<<std::hex<<std::setw(6)
-                     <<std::setfill('0')<<j<<std::dec
-                     <<" ";
-            valinfo(uv[j]);
-        }
-    }
-}
-
-void vm::detail() {
-    reginfo();
-    gstate();
-    lstate();
-    ustate();
-}
-
-void vm::die(const string& str) {
-    std::cerr<<"[vm] error: "<<str<<"\n";
-    traceback();
-    stackinfo();
-
-    // show verbose crash info
-    if (verbose) {
-        detail();
-    }
-
-    if (ngc.rctx->stack==stack) { // in main context, exit directly
-        std::exit(1);
-    } else { // in coroutine, shut down the coroutine and return to main context
-        ctx.pc=0; // mark coroutine 'dead'
-        ngc.ctxreserve();
-        ctx.top[0]=nil;
-    }
-}
-
-inline bool vm::cond(var& val) {
-    if (val.type==vm_num) {
-        return val.num();
-    } else if (val.type==vm_str) {
-        const f64 num=str2num(val.str().c_str());
-        return std::isnan(num)? !val.str().empty():num;
-    }
-    return false;
-}
-
-void vm::o_intg() {
-    // global values store on stack
-    ctx.top+=imm[ctx.pc];
-    --ctx.top;// point to the top
-}
-
-void vm::o_intl() {
-    ctx.top[0].func().local.resize(imm[ctx.pc], nil);
-    ctx.top[0].func().lsize=imm[ctx.pc];
-}
-
-void vm::o_loadg() {
-    stack[imm[ctx.pc]]=(ctx.top--)[0];
-}
-
-void vm::o_loadl() {
-    ctx.localr[imm[ctx.pc]]=(ctx.top--)[0];
-}
-
-void vm::o_loadu() {
-    ctx.funcr.func().upval[(imm[ctx.pc]>>16)&0xffff]
-         .upval()[imm[ctx.pc]&0xffff]=(ctx.top--)[0];
-}
-
-void vm::o_pnum() {
-    (++ctx.top)[0]=var::num(cnum[imm[ctx.pc]]);
-}
-
-void vm::o_pnil() {
-    (++ctx.top)[0]=nil;
-}
-
-void vm::o_pstr() {
-    (++ctx.top)[0]=ngc.strs[imm[ctx.pc]];
-}
-
-void vm::o_newv() {
-    var newv=ngc.alloc(vm_vec);
-    auto& vec=newv.vec().elems;
-    vec.resize(imm[ctx.pc]);
-    // use top-=imm[pc]-1 here will cause error if imm[pc] is 0
-    ctx.top=ctx.top-imm[ctx.pc]+1;
-    for(u32 i=0;i<imm[ctx.pc];++i) {
-        vec[i]=ctx.top[i];
-    }
-    ctx.top[0]=newv;
-}
-
-void vm::o_newh() {
-    (++ctx.top)[0]=ngc.alloc(vm_hash);
-}
-
-void vm::o_newf() {
-    (++ctx.top)[0]=ngc.alloc(vm_func);
-    nas_func& func=ctx.top[0].func();
-    func.entry=imm[ctx.pc];
-    func.psize=1;
-
-    /* this means you create a new function in local scope */
-    if (ctx.localr) {
-        func.upval=ctx.funcr.func().upval;
-        // function created in the same local scope shares one closure
-        // so this size & stk setting has no problem
-        var upval=(ctx.upvalr.type==vm_nil)?ngc.alloc(vm_upval):ctx.upvalr;
-        upval.upval().size=ctx.funcr.func().lsize;
-        upval.upval().stk=ctx.localr;
-        func.upval.push_back(upval);
-        ctx.upvalr=upval;
-    }
-}
-
-void vm::o_happ() {
-    ctx.top[-1].hash().elems[cstr[imm[ctx.pc]]]=ctx.top[0];
-    --ctx.top;
-}
-
-void vm::o_para() {
-    nas_func& func=ctx.top[0].func();
-    // func->size has 1 place reserved for "me"
-    func.keys[imm[ctx.pc]]=func.psize;
-    func.local[func.psize++]=var::none();
-}
-
-void vm::o_deft() {
-    var val=ctx.top[0];
-    nas_func& func=(--ctx.top)[0].func();
-    // func->size has 1 place reserved for "me"
-    func.keys[imm[ctx.pc]]=func.psize;
-    func.local[func.psize++]=val;
-}
-
-void vm::o_dyn() {
-    ctx.top[0].func().dpara=imm[ctx.pc];
-}
-
-void vm::o_lnot() {
-    var val=ctx.top[0];
-    switch(val.type) {
-        case vm_nil:ctx.top[0]=one;break;
-        case vm_num:ctx.top[0]=val.num()?zero:one;break;
-        case vm_str:{
-            const f64 num=str2num(val.str().c_str());
-            if (std::isnan(num)) {
-                ctx.top[0]=var::num((f64)val.str().empty());
-            } else {
-                ctx.top[0]=num?zero:one;
-            }
-        } break;
-        default:{
-            die("incorrect value type");
-            return;
-        } break;
-    }
-}
-
-void vm::o_usub() {
-    ctx.top[0]=var::num(-ctx.top[0].tonum());
-}
-
-void vm::o_bnot() {
-    ctx.top[0]=var::num(~static_cast<int32_t>(ctx.top[0].num()));
-}
-
-void vm::o_btor() {
-    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())|static_cast<int32_t>(ctx.top[0].tonum()));
-    --ctx.top;
-}
-
-void vm::o_btxor() {
-    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())^static_cast<int32_t>(ctx.top[0].tonum()));
-    --ctx.top;
-}
-
-void vm::o_btand() {
-    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())&static_cast<int32_t>(ctx.top[0].tonum()));
-    --ctx.top;
-}
-
-#define op_calc(type)\
-    ctx.top[-1]=var::num(ctx.top[-1].tonum() type ctx.top[0].tonum());\
-    --ctx.top;
-
-void vm::o_add() {op_calc(+);}
-void vm::o_sub() {op_calc(-);}
-void vm::o_mul() {op_calc(*);}
-void vm::o_div() {op_calc(/);}
-void vm::o_lnk() {
-    ctx.top[-1]=ngc.newstr(ctx.top[-1].tostr()+ctx.top[0].tostr());
-    --ctx.top;
-}
-
-#define op_calc_const(type)\
-    ctx.top[0]=var::num(ctx.top[0].tonum() type cnum[imm[ctx.pc]]);
-
-void vm::o_addc() {op_calc_const(+);}
-void vm::o_subc() {op_calc_const(-);}
-void vm::o_mulc() {op_calc_const(*);}
-void vm::o_divc() {op_calc_const(/);}
-void vm::o_lnkc() {
-    ctx.top[0]=ngc.newstr(ctx.top[0].tostr()+cstr[imm[ctx.pc]]);
-}
-
-// top[0] stores the value of memr[0], to avoid being garbage-collected
-// so when the calculation ends, top-=1, then top-=imm[pc]
-// because this return value is meaningless if on stack when imm[pc]=1
-// like this: func{a+=c;}(); the result of 'a+c' will no be used later, imm[pc]=1
-// but if b+=a+=c; the result of 'a+c' will be used later, imm[pc]=0
-#define op_calc_eq(type)\
-    ctx.top[-1]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type ctx.top[-1].tonum());\
-    ctx.memr=nullptr;\
-    ctx.top-=imm[ctx.pc]+1;
-
-void vm::o_addeq() {op_calc_eq(+);}
-void vm::o_subeq() {op_calc_eq(-);}
-void vm::o_muleq() {op_calc_eq(*);}
-void vm::o_diveq() {op_calc_eq(/);}
-void vm::o_lnkeq() {
-    ctx.top[-1]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+ctx.top[-1].tostr());
-    ctx.memr=nullptr;
-    ctx.top-=imm[ctx.pc]+1;
-}
-
-void vm::o_bandeq() {
-    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())&i32(ctx.top[-1].tonum()));
-    ctx.memr=nullptr;
-    ctx.top-=imm[ctx.pc]+1;
-}
-
-void vm::o_boreq() {
-    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())|i32(ctx.top[-1].tonum()));
-    ctx.memr=nullptr;
-    ctx.top-=imm[ctx.pc]+1;
-}
-
-void vm::o_bxoreq() {
-    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())^i32(ctx.top[-1].tonum()));
-    ctx.memr=nullptr;
-    ctx.top-=imm[ctx.pc]+1;
-}
-
-// top[0] stores the value of memr[0], to avoid being garbage-collected
-// so when the calculation ends, top-=imm[pc]>>31
-// because this return value is meaningless if on stack when imm[pc]>>31=1
-// like this: func{a+=1;}(); the result of 'a+1' will no be used later, imm[pc]>>31=1
-// but if b+=a+=1; the result of 'a+1' will be used later, imm[pc]>>31=0
-#define op_calc_eq_const(type)\
-    ctx.top[0]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type cnum[imm[ctx.pc]]);\
-    ctx.memr=nullptr;
-
-void vm::o_addeqc() {op_calc_eq_const(+);}
-void vm::o_subeqc() {op_calc_eq_const(-);}
-void vm::o_muleqc() {op_calc_eq_const(*);}
-void vm::o_diveqc() {op_calc_eq_const(/);}
-void vm::o_lnkeqc() {
-    ctx.top[0]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+cstr[imm[ctx.pc]]);
-    ctx.memr=nullptr;
-}
-
-#define op_calc_eq_const_and_pop(type)\
-    ctx.top[0]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type cnum[imm[ctx.pc]]);\
-    ctx.memr=nullptr;\
-    --ctx.top;
-
-void vm::o_addecp() {op_calc_eq_const_and_pop(+);}
-void vm::o_subecp() {op_calc_eq_const_and_pop(-);}
-void vm::o_mulecp() {op_calc_eq_const_and_pop(*);}
-void vm::o_divecp() {op_calc_eq_const_and_pop(/);}
-void vm::o_lnkecp() {
-    ctx.top[0]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+cstr[imm[ctx.pc]]);
-    ctx.memr=nullptr;
-    --ctx.top;
-}
-
-void vm::o_meq() {
-    // pop old memr[0] and replace it
-    // the reason why we should get memr and push the old value on stack
-    // is that when lnkeq/lnkeqc is called, there will be
-    // a new gc object vm_str which is returned by gc::alloc
-    // this may cause gc, so we should temporarily put it on stack
-    ctx.memr[0]=ctx.top[-1];
-    ctx.memr=nullptr;
-    ctx.top-=imm[ctx.pc]+1;
-}
-
-void vm::o_eq() {
-    var val2=ctx.top[0];
-    var val1=(--ctx.top)[0];
-    if (val1.type==vm_nil && val2.type==vm_nil) {
-        ctx.top[0]=one;
-    } else if (val1.type==vm_str && val2.type==vm_str) {
-        ctx.top[0]=(val1.str()==val2.str())?one:zero;
-    } else if ((val1.type==vm_num || val2.type==vm_num)
-        && val1.type!=vm_nil && val2.type!=vm_nil) {
-        ctx.top[0]=(val1.tonum()==val2.tonum())?one:zero;
-    } else {
-        ctx.top[0]=(val1==val2)?one:zero;
-    }
-}
-
-void vm::o_neq() {
-    var val2=ctx.top[0];
-    var val1=(--ctx.top)[0];
-    if (val1.type==vm_nil && val2.type==vm_nil) {
-        ctx.top[0]=zero;
-    } else if (val1.type==vm_str && val2.type==vm_str) {
-        ctx.top[0]=(val1.str()!=val2.str())?one:zero;
-    } else if ((val1.type==vm_num || val2.type==vm_num)
-        && val1.type!=vm_nil && val2.type!=vm_nil) {
-        ctx.top[0]=(val1.tonum()!=val2.tonum())?one:zero;
-    } else {
-        ctx.top[0]=(val1!=val2)?one:zero;
-    }
-}
-
-#define op_cmp(type)\
-    --ctx.top;\
-    ctx.top[0]=(ctx.top[0].tonum() type ctx.top[1].tonum())?one:zero;
-
-void vm::o_less() {op_cmp(<);}
-void vm::o_leq() {op_cmp(<=);}
-void vm::o_grt() {op_cmp(>);}
-void vm::o_geq() {op_cmp(>=);}
-
-#define op_cmp_const(type)\
-    ctx.top[0]=(ctx.top[0].tonum() type cnum[imm[ctx.pc]])?one:zero;
-
-void vm::o_lessc() {op_cmp_const(<);}
-void vm::o_leqc() {op_cmp_const(<=);}
-void vm::o_grtc() {op_cmp_const(>);}
-void vm::o_geqc() {op_cmp_const(>=);}
-
-void vm::o_pop() {
-    --ctx.top;
-}
-
-void vm::o_jmp() {
-    ctx.pc=imm[ctx.pc]-1;
-}
-
-void vm::o_jt() {
-    // jump true needs to reserve the result on stack
-    // because conditional expression in nasal has return value
-    if (cond(ctx.top[0])) {
-        ctx.pc=imm[ctx.pc]-1;
-    }
-}
-
-void vm::o_jf() {
-    // jump false doesn't need to reserve result
-    if (!cond(ctx.top[0])) {
-        ctx.pc=imm[ctx.pc]-1;
-    }
-    --ctx.top;
-}
-
-void vm::o_cnt() {
-    if (ctx.top[0].type!=vm_vec) {
-        die("must use vector in forindex/foreach");
-        return;
-    }
-    (++ctx.top)[0]=var::cnt(-1);
-}
-
-void vm::o_findex() {
-    if ((usize)(++ctx.top[0].cnt())>=ctx.top[-1].vec().size()) {
-        ctx.pc=imm[ctx.pc]-1;
-        return;
-    }
-    ctx.top[1]=var::num(ctx.top[0].cnt());
-    ++ctx.top;
-}
-
-void vm::o_feach() {
-    auto& ref=ctx.top[-1].vec().elems;
-    if ((usize)(++ctx.top[0].cnt())>=ref.size()) {
-        ctx.pc=imm[ctx.pc]-1;
-        return;
-    }
-    ctx.top[1]=ref[ctx.top[0].cnt()];
-    ++ctx.top;
-}
-
-void vm::o_callg() {
-    // get main stack directly
-    (++ctx.top)[0]=stack[imm[ctx.pc]];
-}
-
-void vm::o_calll() {
-    (++ctx.top)[0]=ctx.localr[imm[ctx.pc]];
-}
-
-void vm::o_upval() {
-    (++ctx.top)[0]=ctx.funcr.func()
-        .upval[(imm[ctx.pc]>>16)&0xffff]
-        .upval()[imm[ctx.pc]&0xffff];
-}
-
-void vm::o_callv() {
-    var val=ctx.top[0];
-    var vec=(--ctx.top)[0];
-    if (vec.type==vm_vec) {
-        ctx.top[0]=vec.vec().get_val(val.tonum());
-        if (ctx.top[0].type==vm_none) {
-            die("out of range:"+std::to_string(val.tonum()));
-            return;
-        }
-    } else if (vec.type==vm_hash) {
-        if (val.type!=vm_str) {
-            die("must use string as the key");
-            return;
-        }
-        ctx.top[0]=vec.hash().get_val(val.str());
-        if (ctx.top[0].type==vm_none) {
-            die("cannot find member \""+val.str()+"\"");
-            return;
-        } else if (ctx.top[0].type==vm_func) {
-            ctx.top[0].func().local[0]=val; // 'me'
-        }
-    } else if (vec.type==vm_str) {
-        string& str=vec.str();
-        i32 num=val.tonum();
-        i32 len=str.length();
-        if (num<-len || num>=len) {
-            die("out of range:"+std::to_string(val.tonum()));
-            return;
-        }
-        ctx.top[0]=var::num(f64((u8)str[num>=0? num:num+len]));
-    } else {
-        die("must call a vector/hash/string");
-        return;
-    }
-}
-
-void vm::o_callvi() {
-    var val=ctx.top[0];
-    if (val.type!=vm_vec) {
-        die("must use a vector");
-        return;
-    }
-    // cannot use operator[],because this may cause overflow
-    (++ctx.top)[0]=val.vec().get_val(imm[ctx.pc]);
-    if (ctx.top[0].type==vm_none) {
-        die("out of range:"+std::to_string(imm[ctx.pc]));
-        return;
-    }
-}
-
-void vm::o_callh() {
-    var val=ctx.top[0];
-    if (val.type!=vm_hash) {
-        die("must call a hash");
-        return;
-    }
-    ctx.top[0]=val.hash().get_val(cstr[imm[ctx.pc]]);
-    if (ctx.top[0].type==vm_none) {
-        die("member \""+cstr[imm[ctx.pc]]+"\" does not exist");
-        return;
-    } else if (ctx.top[0].type==vm_func) {
-        ctx.top[0].func().local[0]=val; // 'me'
-    }
-}
-
-void vm::o_callfv() {
-    u32 argc=imm[ctx.pc]; // arguments counter
-    var* local=ctx.top-argc+1; // arguments begin address
-    if (local[-1].type!=vm_func) {
-        die("must call a function");
-        return;
-    }
-    auto& func=local[-1].func();
-    var tmp=local[-1];
-    local[-1]=ctx.funcr;
-    ctx.funcr=tmp;
-    // top-argc+lsize(local) +1(old pc) +1(old localr) +1(old upvalr)
-    if (ctx.top-argc+func.lsize+3>=ctx.canary) {
-        die("stack overflow");
-        return;
-    }
-    // parameter size is func->psize-1, 1 is reserved for "me"
-    u32 psize=func.psize-1;
-    if (argc<psize && func.local[argc+1].type==vm_none) {
-        die("lack argument(s)");
-        return;
-    }
-
-    var dynamic=nil;
-    if (func.dpara>=0) { // load dynamic arguments
-        dynamic=ngc.alloc(vm_vec);
-        for(u32 i=psize;i<argc;++i) {
-            dynamic.vec().elems.push_back(local[i]);
-        }
-    }
-    // should reset stack top after allocating vector
-    // because this may cause gc
-    // then all the available values the vector needs
-    // are all outside the stack top and may be
-    // collected incorrectly
-    ctx.top=local+func.lsize;
-
-    u32 min_size=(std::min)(psize, argc); // avoid error in MSVC
-    for(u32 i=min_size;i>=1;--i) { // load arguments
-        local[i]=local[i-1];
-    }
-    local[0]=func.local[0];// load "me"
-    // load local scope & default arguments
-    for(u32 i=min_size+1;i<func.lsize;++i) {
-        local[i]=func.local[i];
-    }
-    if (func.dpara>=0) {
-        local[psize+1]=dynamic;
-    }
-
-    ctx.top[0]=ctx.upvalr;
-    (++ctx.top)[0]=var::addr(ctx.localr);
-    (++ctx.top)[0]=var::ret(ctx.pc);
-    ctx.pc=func.entry-1;
-    ctx.localr=local;
-    ctx.upvalr=nil;
-}
-
-void vm::o_callfh() {
-    auto& hash=ctx.top[0].hash().elems;
-    if (ctx.top[-1].type!=vm_func) {
-        die("must call a function");
-        return;
-    }
-    auto& func=ctx.top[-1].func();
-    var tmp=ctx.top[-1];
-    ctx.top[-1]=ctx.funcr;
-    ctx.funcr=tmp;
-
-    // top -1(hash) +lsize(local) +1(old pc) +1(old localr) +1(old upvalr)
-    if (ctx.top+func.lsize+2>=ctx.canary) {
-        die("stack overflow");
-        return;
-    }
-    if (func.dpara>=0) {
-        die("special call cannot use dynamic argument");
-        return;
-    }
-
-    var* local=ctx.top;
-    ctx.top+=func.lsize;
-    for(u32 i=0;i<func.lsize;++i) {
-        local[i]=func.local[i];
-    }
-    
-    for(auto& i:func.keys) {
-        auto& key=cstr[i.first];
-        if (hash.count(key)) {
-            local[i.second]=hash[key];
-        } else if (local[i.second].type==vm_none) {
-            die("lack argument(s): \""+key+"\"");
-            return;
-        }
-    }
-
-    ctx.top[0]=ctx.upvalr;
-    (++ctx.top)[0]=var::addr(ctx.localr);
-    (++ctx.top)[0]=var::ret(ctx.pc); // rewrite top with vm_ret
-    ctx.pc=func.entry-1;
-    ctx.localr=local;
-    ctx.upvalr=nil;
-}
-
-void vm::o_callb() {
-    // reserve place for builtin function return,
-    // this code is written for coroutine
-    (++ctx.top)[0]=nil;
-
-    // if running a builtin function about coroutine
-    // (top) will be set to another context.top, instead of main_context.top
-    var tmp=(*builtin[imm[ctx.pc]].func)(ctx.localr, ngc);
-
-    // so we use tmp variable to store this return value
-    // and set it to top[0] later
-    ctx.top[0]=tmp;
-
-    // if get none, this means errors occurred when calling this native function
-    if (ctx.top[0].type==vm_none) {
-        die("native function error");
-        return;
-    }
-}
-
-void vm::o_slcbeg() {
-    // +--------------+
-    // | slice_vector | <-- top[0]
-    // +--------------+
-    // | resource_vec | <-- top[-1]
-    // +--------------+
-    (++ctx.top)[0]=ngc.alloc(vm_vec);
-    if (ctx.top[-1].type!=vm_vec) {
-        die("must slice a vector");
-        return;
-    }
-}
-
-void vm::o_slcend() {
-    ctx.top[-1]=ctx.top[0];
-    --ctx.top;
-}
-
-void vm::o_slc() {
-    var val=(ctx.top--)[0];
-    var res=ctx.top[-1].vec().get_val(val.tonum());
-    if (res.type==vm_none) {
-        die("index "+std::to_string(val.tonum())+" out of range");
-        return;
-    }
-    ctx.top[0].vec().elems.push_back(res);
-}
-
-void vm::o_slc2() {
-    var val2=(ctx.top--)[0];
-    var val1=(ctx.top--)[0];
-    auto& ref=ctx.top[-1].vec().elems;
-    auto& aim=ctx.top[0].vec().elems;
-
-    u8 type1=val1.type,type2=val2.type;
-    i32 num1=val1.tonum();
-    i32 num2=val2.tonum();
-    i32 size=ref.size();
-    if (type1==vm_nil && type2==vm_nil) {
-        num1=0;
-        num2=size-1;
-    } else if (type1==vm_nil && type2!=vm_nil) {
-        num1=num2<0? -size:0;
-    } else if (type1!=vm_nil && type2==vm_nil) {
-        num2=num1<0? -1:size-1;
-    }
-
-    if (num1<-size || num1>=size || num2<-size || num2>=size) {
-        die("index "+std::to_string(num1)+":"+std::to_string(num2)+" out of range");
-        return;
-    } else if (num1<=num2) {
-        for(i32 i=num1;i<=num2;++i) {
-            aim.push_back(i>=0?ref[i]:ref[i+size]);
-        }
-    }
-}
-
-void vm::o_mcallg() {
-    ctx.memr=stack+imm[ctx.pc];
-    (++ctx.top)[0]=ctx.memr[0];
-    // push value in this memory space on stack
-    // to avoid being garbage collected
-}
-
-void vm::o_mcalll() {
-    ctx.memr=ctx.localr+imm[ctx.pc];
-    (++ctx.top)[0]=ctx.memr[0];
-    // push value in this memory space on stack
-    // to avoid being garbage collected
-}
-
-void vm::o_mupval() {
-    ctx.memr=&(ctx.funcr.func().upval[(imm[ctx.pc]>>16)&0xffff].upval()[imm[ctx.pc]&0xffff]);
-    (++ctx.top)[0]=ctx.memr[0];
-    // push value in this memory space on stack
-    // to avoid being garbage collected
-}
-
-void vm::o_mcallv() {
-    var val=ctx.top[0];     // index
-    var vec=(--ctx.top)[0]; // mcall vector, reserved on stack to avoid gc
-    if (vec.type==vm_vec) {
-        ctx.memr=vec.vec().get_mem(val.tonum());
-        if (!ctx.memr) {
-            die("index "+std::to_string(val.tonum())+" out of range");
-            return;
-        }
-    } else if (vec.type==vm_hash) { // do mcallh but use the mcallv way
-        if (val.type!=vm_str) {
-            die("key must be string");
-            return;
-        }
-        nas_hash& ref=vec.hash();
-        string& str=val.str();
-        ctx.memr=ref.get_mem(str);
-        if (!ctx.memr) {
-            ref.elems[str]=nil;
-            ctx.memr=ref.get_mem(str);
-        }
-    } else {
-        die("cannot get memory space in this type");
-        return;
-    }
-}
-
-void vm::o_mcallh() {
-    var hash=ctx.top[0]; // mcall hash, reserved on stack to avoid gc
-    if (hash.type!=vm_hash) {
-        die("must call a hash");
-        return;
-    }
-    auto& ref=hash.hash();
-    auto& str=cstr[imm[ctx.pc]];
-    ctx.memr=ref.get_mem(str);
-    if (!ctx.memr) { // create a new key
-        ref.elems[str]=nil;
-        ctx.memr=ref.get_mem(str);
-    }
-}
-
-void vm::o_ret() {
-/*  +-------------+
-*   | return value| <- top[0]
-*   +-------------+
-*   | old pc      | <- top[-1]
-*   +-------------+
-*   | old localr  | <- top[-2]
-*   +-------------+
-*   | old upvalr  | <- top[-3]
-*   +-------------+
-*   | local scope |
-*   +-------------+ <- local pointer stored in localr
-*   | old funcr   | <- old function stored in funcr
-*   +-------------+
-*/
-    var  ret  =ctx.top[0];
-    var* local=ctx.localr;
-    var  func =ctx.funcr;
-    var  up   =ctx.upvalr;
-
-    ctx.pc    =ctx.top[-1].ret();
-    ctx.localr=ctx.top[-2].addr();
-    ctx.upvalr=ctx.top[-3];
-
-    ctx.top=local-1;
-    ctx.funcr=ctx.top[0];
-    ctx.top[0]=ret; // rewrite func with returned value
-
-    if (up.type==vm_upval) { // synchronize upvalue
-        auto& upval=up.upval();
-        auto size=func.func().lsize;
-        upval.onstk=false;
-        upval.elems.resize(size);
-        for(u32 i=0;i<size;++i) {
-            upval.elems[i]=local[i];
-        }
-    }
-
-    // cannot use gc.cort to judge,
-    // because there maybe another function call inside but return here
-    // coroutine function ends with setting pc to 0
-    if (!ctx.pc) {
-        ngc.ctxreserve();
-    }
-}
-
-void vm::run(
-    const codegen& gen,
-    const linker& linker,
-    const std::vector<string>& argv,
-    const bool detail
-) {
-    verbose=detail;
-    init(gen.strs(), gen.nums(), gen.codes(), linker.filelist(), argv);
-#ifndef _MSC_VER
-    const void* oprs[]={
-        &&vmexit, &&intg,   &&intl,   &&loadg,
-        &&loadl,  &&loadu,  &&pnum,   &&pnil,
-        &&pstr,   &&newv,   &&newh,   &&newf,
-        &&happ,   &&para,   &&deft,   &&dyn,
-        &&lnot,   &&usub,   &&bnot,   &&btor,
-        &&btxor,  &&btand,  &&add,    &&sub,
-        &&mul,    &&div,    &&lnk,    &&addc,
-        &&subc,   &&mulc,   &&divc,   &&lnkc,
-        &&addeq,  &&subeq,  &&muleq,  &&diveq,
-        &&lnkeq,  &&bandeq, &&boreq,  &&bxoreq,
-        &&addeqc, &&subeqc, &&muleqc, &&diveqc,
-        &&lnkeqc, &&addecp, &&subecp, &&mulecp,
-        &&divecp, &&lnkecp, &&meq,    &&eq,
-        &&neq,    &&less,   &&leq,    &&grt,
-        &&geq,    &&lessc,  &&leqc,   &&grtc,
-        &&geqc,   &&pop,    &&jmp,    &&jt,
-        &&jf,     &&cnt,    &&findex, &&feach,
-        &&callg,  &&calll,  &&upval,  &&callv,
-        &&callvi, &&callh,  &&callfv, &&callfh,
-        &&callb,  &&slcbeg, &&slcend, &&slc,
-        &&slc2,   &&mcallg, &&mcalll, &&mupval,
-        &&mcallv, &&mcallh, &&ret
-    };
-    std::vector<const void*> code;
-    for(auto& i:gen.codes()) {
-        code.push_back(oprs[i.op]);
-        imm.push_back(i.num);
-    }
-    // goto the first operand
-    goto *code[ctx.pc];
-#else
-    typedef void (vm::*nafunc)();
-    const nafunc oprs[]={
-        nullptr,       &vm::o_intg,
-        &vm::o_intl,   &vm::o_loadg,
-        &vm::o_loadl,  &vm::o_loadu,
-        &vm::o_pnum,   &vm::o_pnil,
-        &vm::o_pstr,   &vm::o_newv,
-        &vm::o_newh,   &vm::o_newf,
-        &vm::o_happ,   &vm::o_para,
-        &vm::o_deft,   &vm::o_dyn,
-        &vm::o_lnot,   &vm::o_usub,
-        &vm::o_bnot,   &vm::o_btor,
-        &vm::o_btxor,  &vm::o_btand,
-        &vm::o_add,    &vm::o_sub,
-        &vm::o_mul,    &vm::o_div,
-        &vm::o_lnk,    &vm::o_addc,
-        &vm::o_subc,   &vm::o_mulc,
-        &vm::o_divc,   &vm::o_lnkc,
-        &vm::o_addeq,  &vm::o_subeq,
-        &vm::o_muleq,  &vm::o_diveq,
-        &vm::o_lnkeq,  &vm::o_bandeq,
-        &vm::o_boreq,  &vm::o_bxoreq,
-        &vm::o_addeqc, &vm::o_subeqc,
-        &vm::o_muleqc, &vm::o_diveqc,
-        &vm::o_lnkeqc, &vm::o_addecp,
-        &vm::o_subecp, &vm::o_mulecp,
-        &vm::o_divecp, &vm::o_lnkecp,
-        &vm::o_meq,    &vm::o_eq,
-        &vm::o_neq,    &vm::o_less,
-        &vm::o_leq,    &vm::o_grt,
-        &vm::o_geq,    &vm::o_lessc,
-        &vm::o_leqc,   &vm::o_grtc,
-        &vm::o_geqc,   &vm::o_pop,
-        &vm::o_jmp,    &vm::o_jt,
-        &vm::o_jf,     &vm::o_cnt,
-        &vm::o_findex, &vm::o_feach,
-        &vm::o_callg,  &vm::o_calll,
-        &vm::o_upval,  &vm::o_callv,
-        &vm::o_callvi, &vm::o_callh,
-        &vm::o_callfv, &vm::o_callfh,
-        &vm::o_callb,  &vm::o_slcbeg,
-        &vm::o_slcend, &vm::o_slc,
-        &vm::o_slc2,   &vm::o_mcallg,
-        &vm::o_mcalll, &vm::o_mupval,
-        &vm::o_mcallv, &vm::o_mcallh,
-        &vm::o_ret
-    };
-    std::vector<nafunc> code;
-    for(auto& i:gen.codes()) {
-        code.push_back(oprs[i.op]);
-        imm.push_back(i.num);
-    }
-    while(code[ctx.pc]) {
-        (this->*code[ctx.pc])();
-        if (ctx.top>=ctx.canary) {
-            die("stack overflow");
-        }
-        ++ctx.pc;
-    }
-#endif
-
-vmexit:
-    if (detail) {
-        ngc.info();
-    }
-    ngc.clear();
-    imm.clear();
-    return;
-
-#ifndef _MSC_VER
-// may cause stackoverflow
-#define exec_check(op) {\
-        op();\
-        if (ctx.top<ctx.canary)\
-            goto *code[++ctx.pc];\
-        die("stack overflow");\
-        goto *code[++ctx.pc];\
-    }
-// do not cause stackoverflow
-#define exec_nodie(op) {op();goto *code[++ctx.pc];}
-
-intg:   exec_nodie(o_intg  ); // +imm[pc] (detected at codegen)
-intl:   exec_nodie(o_intl  ); // -0
-loadg:  exec_nodie(o_loadg ); // -1
-loadl:  exec_nodie(o_loadl ); // -1
-loadu:  exec_nodie(o_loadu ); // -1
-pnum:   exec_check(o_pnum  ); // +1
-pnil:   exec_check(o_pnil  ); // +1
-pstr:   exec_check(o_pstr  ); // +1
-newv:   exec_check(o_newv  ); // +1-imm[pc]
-newh:   exec_check(o_newh  ); // +1
-newf:   exec_check(o_newf  ); // +1
-happ:   exec_nodie(o_happ  ); // -1
-para:   exec_nodie(o_para  ); // -0
-deft:   exec_nodie(o_deft  ); // -1
-dyn:    exec_nodie(o_dyn   ); // -0
-lnot:   exec_nodie(o_lnot  ); // -0
-usub:   exec_nodie(o_usub  ); // -0
-bnot:   exec_nodie(o_bnot  ); // -0
-btor:   exec_nodie(o_btor  ); // -1
-btxor:  exec_nodie(o_btxor ); // -1
-btand:  exec_nodie(o_btand ); // -1
-add:    exec_nodie(o_add   ); // -1
-sub:    exec_nodie(o_sub   ); // -1
-mul:    exec_nodie(o_mul   ); // -1
-div:    exec_nodie(o_div   ); // -1
-lnk:    exec_nodie(o_lnk   ); // -1
-addc:   exec_nodie(o_addc  ); // -0
-subc:   exec_nodie(o_subc  ); // -0
-mulc:   exec_nodie(o_mulc  ); // -0
-divc:   exec_nodie(o_divc  ); // -0
-lnkc:   exec_nodie(o_lnkc  ); // -0
-addeq:  exec_nodie(o_addeq ); // -1
-subeq:  exec_nodie(o_subeq ); // -1
-muleq:  exec_nodie(o_muleq ); // -1
-diveq:  exec_nodie(o_diveq ); // -1
-lnkeq:  exec_nodie(o_lnkeq ); // -1
-bandeq: exec_nodie(o_bandeq); // -1
-boreq:  exec_nodie(o_boreq ); // -1
-bxoreq: exec_nodie(o_bxoreq); // -1
-addeqc: exec_nodie(o_addeqc); // -0
-subeqc: exec_nodie(o_subeqc); // -0
-muleqc: exec_nodie(o_muleqc); // -0
-diveqc: exec_nodie(o_diveqc); // -0
-lnkeqc: exec_nodie(o_lnkeqc); // -0
-addecp: exec_nodie(o_addecp); // -1
-subecp: exec_nodie(o_subecp); // -1
-mulecp: exec_nodie(o_mulecp); // -1
-divecp: exec_nodie(o_divecp); // -1
-lnkecp: exec_nodie(o_lnkecp); // -1
-meq:    exec_nodie(o_meq   ); // -1
-eq:     exec_nodie(o_eq    ); // -1
-neq:    exec_nodie(o_neq   ); // -1
-less:   exec_nodie(o_less  ); // -1
-leq:    exec_nodie(o_leq   ); // -1
-grt:    exec_nodie(o_grt   ); // -1
-geq:    exec_nodie(o_geq   ); // -1
-lessc:  exec_nodie(o_lessc ); // -0
-leqc:   exec_nodie(o_leqc  ); // -0
-grtc:   exec_nodie(o_grtc  ); // -0
-geqc:   exec_nodie(o_geqc  ); // -0
-pop:    exec_nodie(o_pop   ); // -1
-jmp:    exec_nodie(o_jmp   ); // -0
-jt:     exec_nodie(o_jt    ); // -0
-jf:     exec_nodie(o_jf    ); // -1
-cnt:    exec_nodie(o_cnt   ); // -0
-findex: exec_check(o_findex); // +1
-feach:  exec_check(o_feach ); // +1
-callg:  exec_check(o_callg ); // +1
-calll:  exec_check(o_calll ); // +1
-upval:  exec_check(o_upval ); // +1
-callv:  exec_nodie(o_callv ); // -0
-callvi: exec_nodie(o_callvi); // -0
-callh:  exec_nodie(o_callh ); // -0
-callfv: exec_nodie(o_callfv); // check in the function
-callfh: exec_nodie(o_callfh); // check in the function
-callb:  exec_nodie(o_callb ); // -0
-slcbeg: exec_check(o_slcbeg); // +1
-slcend: exec_nodie(o_slcend); // -1
-slc:    exec_nodie(o_slc   ); // -1
-slc2:   exec_nodie(o_slc2  ); // -2
-mcallg: exec_check(o_mcallg); // +1
-mcalll: exec_check(o_mcalll); // +1
-mupval: exec_check(o_mupval); // +1
-mcallv: exec_nodie(o_mcallv); // -0
-mcallh: exec_nodie(o_mcallh); // -0
-ret:    exec_nodie(o_ret   ); // -2
-#endif
-}
diff --git a/src/ast_dumper.cpp b/src/ast_dumper.cpp
index 80c344a..2596527 100644
--- a/src/ast_dumper.cpp
+++ b/src/ast_dumper.cpp
@@ -148,6 +148,14 @@ bool ast_dumper::visit_ternary_operator(ternary_operator* node) {
 }
 
 bool ast_dumper::visit_binary_operator(binary_operator* node) {
+    if (node->get_optimized_number()) {
+        node->get_optimized_number()->accept(this);
+        return true;
+    }
+    if (node->get_optimized_string()) {
+        node->get_optimized_string()->accept(this);
+        return true;
+    }
     dump_indent();
     std::cout << "binary_operator ";
     switch(node->get_operator_type()) {
@@ -178,6 +186,10 @@ bool ast_dumper::visit_binary_operator(binary_operator* node) {
 }
 
 bool ast_dumper::visit_unary_operator(unary_operator* node) {
+    if (node->get_optimized_number()) {
+        node->get_optimized_number()->accept(this);
+        return true;
+    }
     dump_indent();
     std::cout << "unary_operator ";
     switch(node->get_operator_type()) {
diff --git a/src/nasal_new_ast.cpp b/src/nasal_new_ast.cpp
index cbc6bd1..79d1140 100644
--- a/src/nasal_new_ast.cpp
+++ b/src/nasal_new_ast.cpp
@@ -119,6 +119,12 @@ binary_operator::~binary_operator() {
     if (right) {
         delete right;
     }
+    if (optimized_const_number) {
+        delete optimized_const_number;
+    }
+    if (optimized_const_string) {
+        delete optimized_const_string;
+    }
 }
 
 void binary_operator::accept(ast_visitor* visitor) {
@@ -129,6 +135,9 @@ unary_operator::~unary_operator() {
     if (value) {
         delete value;
     }
+    if (optimized_number) {
+        delete optimized_number;
+    }
 }
 
 void unary_operator::accept(ast_visitor* visitor) {
diff --git a/src/nasal_new_ast.h b/src/nasal_new_ast.h
index f1dc306..c2a030d 100644
--- a/src/nasal_new_ast.h
+++ b/src/nasal_new_ast.h
@@ -299,18 +299,26 @@ private:
     binary_type type;
     expr* left;
     expr* right;
+    number_literal* optimized_const_number;
+    string_literal* optimized_const_string;
 
 public:
     binary_operator(const span& location):
         expr(location, expr_type::ast_binary),
-        left(nullptr), right(nullptr) {}
+        left(nullptr), right(nullptr),
+        optimized_const_number(nullptr),
+        optimized_const_string(nullptr) {}
     ~binary_operator();
     void set_operator_type(binary_type operator_type) {type = operator_type;}
     void set_left(expr* node) {left = node;}
     void set_right(expr* node) {right = node;}
+    void set_optimized_number(number_literal* node) {optimized_const_number = node;}
+    void set_optimized_string(string_literal* node) {optimized_const_string = node;}
     binary_type get_operator_type() const {return type;}
     expr* get_left() {return left;}
     expr* get_right() {return right;}
+    number_literal* get_optimized_number() {return optimized_const_number;}
+    string_literal* get_optimized_string() {return optimized_const_string;}
     void accept(ast_visitor*) override;
 };
 
@@ -325,16 +333,19 @@ public:
 private:
     unary_type type;
     expr* value;
+    number_literal* optimized_number;
 
 public:
     unary_operator(const span& location):
         expr(location, expr_type::ast_unary),
-        value(nullptr) {}
+        value(nullptr), optimized_number(nullptr) {}
     ~unary_operator();
     void set_operator_type(unary_type operator_type) {type = operator_type;}
     void set_value(expr* node) {value = node;}
+    void set_optimized_number(number_literal* node) {optimized_number = node;}
     unary_type get_operator_type() const {return type;}
     expr* get_value() {return value;}
+    number_literal* get_optimized_number() {return optimized_number;}
     void accept(ast_visitor*) override;
 };
 
diff --git a/src/nasal_new_codegen.cpp b/src/nasal_new_codegen.cpp
index a2f7065..745ed2b 100644
--- a/src/nasal_new_codegen.cpp
+++ b/src/nasal_new_codegen.cpp
@@ -829,6 +829,16 @@ void codegen::unary_gen(unary_operator* node) {
 }
 
 void codegen::binary_gen(binary_operator* node) {
+    // generate optimized result
+    if (node->get_optimized_number()) {
+        num_gen(node->get_optimized_number());
+        return;
+    }
+    if (node->get_optimized_string()) {
+        str_gen(node->get_optimized_string());
+        return;
+    }
+
     switch(node->get_operator_type()) {
         case binary_operator::binary_type::condition_or: or_gen(node); return;
         case binary_operator::binary_type::condition_and: and_gen(node); return;
diff --git a/src/nasal_new_gc.h b/src/nasal_new_gc.h
index 75cacb4..7e94558 100644
--- a/src/nasal_new_gc.h
+++ b/src/nasal_new_gc.h
@@ -29,7 +29,6 @@
 #include <thread>
 
 #include "nasal_new_header.h"
-#include "nasal_new_err.h"
 
 enum vm_type:u8 {
     /* none-gc object */
diff --git a/src/nasal_new_header.h b/src/nasal_new_header.h
index f2247a7..418601c 100644
--- a/src/nasal_new_header.h
+++ b/src/nasal_new_header.h
@@ -48,4 +48,6 @@ f64 dec2f(const char*);
 f64 str2num(const char*);
 i32 utf8_hdchk(const char);
 std::string chrhex(const char);
-std::string rawstr(const std::string&, const usize maxlen=0);
\ No newline at end of file
+std::string rawstr(const std::string&, const usize maxlen=0);
+
+#include "nasal_new_gc.h"
\ No newline at end of file
diff --git a/src/optimizer.cpp b/src/optimizer.cpp
index b24018c..ed5a0fe 100644
--- a/src/optimizer.cpp
+++ b/src/optimizer.cpp
@@ -1,18 +1,129 @@
 #include "optimizer.h"
 
-void optimizer::const_string(binary_operator* node) {
-
+void optimizer::const_string(
+    binary_operator* node,
+    string_literal* left_node,
+    string_literal* right_node) {
+    if (node->get_operator_type()!=binary_operator::binary_type::concat) {
+        return;
+    }
+    const auto& left = left_node->get_content();
+    const auto& right = right_node->get_content();
+    node->set_optimized_string(
+        new string_literal(node->get_location(), left+right));
 }
 
-void optimizer::const_number(binary_operator* node) {
-    
+void optimizer::const_number(
+    binary_operator* node,
+    number_literal* left_node,
+    number_literal* right_node) {
+    const auto left = left_node->get_number();
+    const auto right = right_node->get_number();
+    f64 res;
+    switch(node->get_operator_type()) {
+        case binary_operator::binary_type::add: res = left+right; break;
+        case binary_operator::binary_type::sub: res = left-right; break;
+        case binary_operator::binary_type::mult: res = left*right; break;
+        case binary_operator::binary_type::div: res = left/right; break;
+        case binary_operator::binary_type::less: res = left<right; break;
+        case binary_operator::binary_type::leq: res = left<=right; break;
+        case binary_operator::binary_type::grt: res = left>right; break;
+        case binary_operator::binary_type::geq: res = left>=right; break;
+        case binary_operator::binary_type::bitwise_or:
+            res = i32(left)|i32(right); break;
+        case binary_operator::binary_type::bitwise_xor:
+            res = i32(left)^i32(right); break;
+        case binary_operator::binary_type::bitwise_and:
+            res = i32(left)&i32(right); break;
+        default: return;
+    }
+    if (std::isinf(res) || std::isnan(res)) {
+        return;
+    }
+    node->set_optimized_number(
+        new number_literal(node->get_location(), res));
+}
+
+void optimizer::const_number(
+    unary_operator* node,
+    number_literal* value_node) {
+    auto res = value_node->get_number();
+    switch(node->get_operator_type()) {
+        case unary_operator::unary_type::negative: res = -res; break;
+        case unary_operator::unary_type::bitwise_not: res = ~i32(res); break;
+        case unary_operator::unary_type::logical_not: res = !res; break;
+    }
+    if (std::isinf(res) || std::isnan(res)) {
+        return;
+    }
+    node->set_optimized_number(
+        new number_literal(node->get_location(), res));
 }
 
 bool optimizer::visit_binary_operator(binary_operator* node) {
+    node->get_left()->accept(this);
+    node->get_right()->accept(this);
+    number_literal* left_num_node = nullptr;
+    number_literal* right_num_node = nullptr;
+    string_literal* left_str_node = nullptr;
+    string_literal* right_str_node = nullptr;
+    if (node->get_left()->get_type()==expr_type::ast_num) {
+        left_num_node = (number_literal*)node->get_left();
+    } else if (node->get_left()->get_type()==expr_type::ast_binary &&
+        ((binary_operator*)node->get_left())->get_optimized_number()) {
+        left_num_node = ((binary_operator*)node->get_left())->get_optimized_number();
+    } else if (node->get_left()->get_type()==expr_type::ast_unary &&
+        ((unary_operator*)node->get_left())->get_optimized_number()) {
+        left_num_node = ((unary_operator*)node->get_left())->get_optimized_number();
+    }
+    if (node->get_right()->get_type()==expr_type::ast_num) {
+        right_num_node = (number_literal*)node->get_right();
+    } else if (node->get_right()->get_type()==expr_type::ast_binary &&
+        ((binary_operator*)node->get_right())->get_optimized_number()) {
+        right_num_node = ((binary_operator*)node->get_right())->get_optimized_number();
+    } else if (node->get_right()->get_type()==expr_type::ast_unary &&
+        ((unary_operator*)node->get_right())->get_optimized_number()) {
+        right_num_node = ((unary_operator*)node->get_right())->get_optimized_number();
+    }
+
+    if (node->get_left()->get_type()==expr_type::ast_str) {
+        left_str_node = (string_literal*)node->get_left();
+    } else if (node->get_left()->get_type()==expr_type::ast_binary &&
+        ((binary_operator*)node->get_left())->get_optimized_string()) {
+        left_str_node = ((binary_operator*)node->get_left())->get_optimized_string();
+    }
+    if (node->get_right()->get_type()==expr_type::ast_str) {
+        right_str_node = (string_literal*)node->get_right();
+    } else if (node->get_right()->get_type()==expr_type::ast_binary &&
+        ((binary_operator*)node->get_right())->get_optimized_string()) {
+        right_str_node = ((binary_operator*)node->get_right())->get_optimized_string();
+    }
+    if (left_num_node && right_num_node) {
+        const_number(node, left_num_node, right_num_node);
+        return true;
+    }
+    if (left_str_node && right_str_node) {
+        const_string(node, left_str_node, right_str_node);
+        return true;
+    }
     return true;
 }
 
 bool optimizer::visit_unary_operator(unary_operator* node) {
+    node->get_value()->accept(this);
+    number_literal* value_node = nullptr;
+    if (node->get_value()->get_type()==expr_type::ast_num) {
+        value_node = (number_literal*)node->get_value();
+    } else if (node->get_value()->get_type()==expr_type::ast_binary &&
+        ((binary_operator*)node->get_value())->get_optimized_number()) {
+        value_node = ((binary_operator*)node->get_value())->get_optimized_number();
+    } else if (node->get_value()->get_type()==expr_type::ast_unary &&
+        ((unary_operator*)node->get_value())->get_optimized_number()) {
+        value_node = ((unary_operator*)node->get_value())->get_optimized_number();
+    }
+    if (value_node) {
+        const_number(node, value_node);
+    }
     return true;
 }
 
diff --git a/src/optimizer.h b/src/optimizer.h
index b26dabd..0ecc53a 100644
--- a/src/optimizer.h
+++ b/src/optimizer.h
@@ -7,8 +7,9 @@
 
 class optimizer:public ast_visitor {
 private:
-    void const_string(binary_operator*);
-    void const_number(binary_operator*);
+    void const_string(binary_operator*, string_literal*, string_literal*);
+    void const_number(binary_operator*, number_literal*, number_literal*);
+    void const_number(unary_operator*, number_literal*);
 
 public:
     bool visit_binary_operator(binary_operator*) override;
@@ -17,67 +18,3 @@ public:
 public:
     void do_optimization(code_block*);
 };
-
-// void const_str(ast& root) {
-//     auto& vec=root.child();
-//     root.set_str(vec[0].str()+vec[1].str());
-//     root.child().clear();
-//     root.set_type(ast_str);
-// }
-
-// void const_num(ast& root) {
-//     auto& vec=root.child();
-//     f64 res=0;
-//     switch(root.type()) {
-//         case ast_add:    res=vec[0].num()+vec[1].num(); break;
-//         case ast_sub:    res=vec[0].num()-vec[1].num(); break;
-//         case ast_mult:   res=vec[0].num()*vec[1].num(); break;
-//         case ast_div:    res=vec[0].num()/vec[1].num(); break;
-//         case ast_less:   res=vec[0].num()<vec[1].num(); break;
-//         case ast_leq:    res=vec[0].num()<=vec[1].num();break;
-//         case ast_grt:    res=vec[0].num()>vec[1].num(); break;
-//         case ast_geq:    res=vec[0].num()>=vec[1].num();break;
-//         case ast_bitor:  res=i32(vec[0].num())|i32(vec[1].num()); break;
-//         case ast_bitxor: res=i32(vec[0].num())^i32(vec[1].num()); break;
-//         case ast_bitand: res=i32(vec[0].num())&i32(vec[1].num()); break;
-//     }
-//     // inf and nan will cause number hashmap error in codegen
-//     if (std::isinf(res) || std::isnan(res)) {
-//         return;
-//     }
-//     root.set_num(res);
-//     root.child().clear();
-//     root.set_type(ast_num);
-// }
-
-// void calc_const(ast& root) {
-//     auto& vec=root.child();
-//     for(auto& i:vec) {
-//         calc_const(i);
-//     }
-//     if (vec.size()==1 && root.type()==ast_neg && vec[0].type()==ast_num) {
-//         f64 res=-vec[0].num();
-//         root.set_num(res);
-//         root.child().clear();
-//         root.set_type(ast_num);
-//         return;
-//     }
-//     if (vec.size()!=2) {
-//         return;
-//     }
-//     if (root.type()!=ast_add && root.type()!=ast_sub &&
-//        root.type()!=ast_mult && root.type()!=ast_div &&
-//        root.type()!=ast_link && root.type()!=ast_less &&
-//        root.type()!=ast_leq && root.type()!=ast_grt &&
-//        root.type()!=ast_geq && root.type()!=ast_bitor &&
-//        root.type()!=ast_bitxor && root.type()!=ast_bitand) {
-//         return;
-//     }
-//     if (root.type()==ast_link &&
-//        vec[0].type()==ast_str && vec[1].type()==ast_str) {
-//         const_str(root);
-//     } else if (root.type()!=ast_link &&
-//             vec[0].type()==ast_num && vec[1].type()==ast_num) {
-//         const_num(root);
-//     }
-// }
\ No newline at end of file
diff --git a/test/calc.nas b/test/calc.nas
index a14692e..6103183 100644
--- a/test/calc.nas
+++ b/test/calc.nas
@@ -2,7 +2,7 @@ import.std.padding;
 import.std.file;
 import.std.sort;
 
-var source=find_all_files_with_extension(".","cpp","h");
+var source=find_all_files_with_extension("./src","cpp","h");
 sort(source,func(a,b){return cmp(a,b)<0});
 
 var lib=find_all_files_with_extension("./std","nas");
@@ -78,7 +78,7 @@ var calc=func(codetype,files,path=""){
     return int(bytes/1024);
 }
 
-var all=calc("source code:",source)
+var all=calc("source code:",source,"src/")
     +calc("lib:",lib,"std/")
     +calc("test file:",testfile,"test/")
     +calc("module:",module,"module/");
diff --git a/test/md5compare.nas b/test/md5compare.nas
index a6e9566..1cb6ebc 100644
--- a/test/md5compare.nas
+++ b/test/md5compare.nas
@@ -54,9 +54,12 @@ var filechecksum=func(){
     foreach(var p;find_all_files_with_extension("./module","nas","cpp")) {
         append(files,"./module/"~p);
     }
-    foreach(var p;find_all_files_with_extension(".","cpp","h","md")) {
+    foreach(var p;find_all_files_with_extension(".","md")) {
         append(files,"./"~p);
     }
+    foreach(var p;find_all_files_with_extension("./src","cpp","h")) {
+        append(files,"./src/"~p);
+    }
     foreach(var p;find_all_files_with_extension("./doc","md")) {
         append(files,"./doc/"~p);
     }