diff --git a/es2panda/binder/binder.cpp b/es2panda/binder/binder.cpp
index 43a98efbaadad7c669278604df5e3d24fc8176da..a094a339ee453509c84826ba16be5d8415e58c52 100644
--- a/es2panda/binder/binder.cpp
+++ b/es2panda/binder/binder.cpp
@@ -93,6 +93,12 @@ void Binder::ThrowUndeclaredExport(const lexer::SourcePosition &pos, const util:
     throw Error(ErrorType::SYNTAX, ss.str(), loc.line, loc.col);
 }
 
+void Binder::AssignIndexToModuleVariable()
+{
+    ASSERT(program_->ModuleRecord());
+    program_->ModuleRecord()->AssignIndexToModuleVariable(topScope_->AsModuleScope());
+}
+
 void Binder::IdentifierAnalysis()
 {
     ASSERT(program_->Ast());
@@ -101,6 +107,9 @@ void Binder::IdentifierAnalysis()
     BuildFunction(topScope_, MAIN_FUNC_NAME);
     ResolveReferences(program_->Ast());
     AddMandatoryParams();
+    if (topScope_->IsModuleScope()) {
+        AssignIndexToModuleVariable();
+    }
 }
 
 void Binder::ValidateExportDecl(const ir::ExportNamedDeclaration *exportDecl)
diff --git a/es2panda/binder/binder.h b/es2panda/binder/binder.h
index 7f07e686e203f76e8e12131625a62b5037b58526..e9213c472e5ba71165c7711659bbb279ff672a93 100644
--- a/es2panda/binder/binder.h
+++ b/es2panda/binder/binder.h
@@ -161,6 +161,7 @@ private:
     }
 
     void AddMandatoryParams();
+    void AssignIndexToModuleVariable();
     void BuildFunction(FunctionScope *funcScope, util::StringView name);
     void BuildScriptFunction(Scope *outerScope, const ir::ScriptFunction *scriptFunc);
     void BuildClassDefinition(ir::ClassDefinition *classDef);
diff --git a/es2panda/binder/scope.cpp b/es2panda/binder/scope.cpp
index 21649a4b8c95046eb94d3c3392e067af5c7bd9fc..634676482a8d63ea7f5b39091cba8c71b4bab17c 100644
--- a/es2panda/binder/scope.cpp
+++ b/es2panda/binder/scope.cpp
@@ -358,6 +358,14 @@ void ModuleScope::ConvertLocalVariableToModuleVariable(ArenaAllocator *allocator
     }
 }
 
+void ModuleScope::AssignIndexToModuleVariable(util::StringView name, uint32_t index)
+{
+    auto *moduleVar = FindLocal(name);
+    ASSERT(moduleVar != nullptr);
+    ASSERT(moduleVar->IsModuleVariable());
+    moduleVar->AsModuleVariable()->AssignIndex(index);
+}
+
 bool ModuleScope::AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
                              [[maybe_unused]] ScriptExtension extension)
 {
diff --git a/es2panda/binder/scope.h b/es2panda/binder/scope.h
index ad0783e33bf004ab87618cc4b0b3cc8fc50a2113..94b3791028e56c0f3558af5cb6b36aebd20cc862 100644
--- a/es2panda/binder/scope.h
+++ b/es2panda/binder/scope.h
@@ -599,6 +599,8 @@ public:
         return ScopeType::MODULE;
     }
 
+    void AssignIndexToModuleVariable(util::StringView name, uint32_t index);
+
     void ConvertLocalVariableToModuleVariable(ArenaAllocator *allocator, util::StringView localName);
 
     bool AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
diff --git a/es2panda/binder/variable.h b/es2panda/binder/variable.h
index 80086ef9f65b1926f1b65501ea19a41d1cb0c504..a17b88885a19d065ed153e5c86eeee397dcdf73b 100644
--- a/es2panda/binder/variable.h
+++ b/es2panda/binder/variable.h
@@ -184,6 +184,19 @@ public:
     }
 
     void SetLexical([[maybe_unused]] Scope *scope, [[maybe_unused]] util::Hotfix *hotfixHelper = nullptr) override;
+
+    void AssignIndex(uint32_t index)
+    {
+        index_ = index;
+    }
+
+    uint32_t Index() const
+    {
+        return index_;
+    }
+
+private:
+    uint32_t index_;
 };
 
 class EnumVariable : public Variable {
diff --git a/es2panda/compiler/base/destructuring.cpp b/es2panda/compiler/base/destructuring.cpp
index 70d9ef0754d749ed9ca0aee4dbe9c1fd9857bf7c..5761a021774bc9898ddb012a2f56585f9e508ed6 100644
--- a/es2panda/compiler/base/destructuring.cpp
+++ b/es2panda/compiler/base/destructuring.cpp
@@ -145,8 +145,8 @@ static void GenArray(PandaGen *pg, const ir::ArrayExpression *array)
     pg->SetLabel(array, labelSet.CatchEnd());
 }
 
-static void GenObjectProperty(PandaGen *pg, const ir::ObjectExpression *object, const ir::Expression *element,
-                              VReg value, VReg propReg)
+static void GenObjectProperty(PandaGen *pg, const ir::ObjectExpression *object,
+                              const ir::Expression *element, VReg value)
 {
     RegScope propScope(pg);
     VReg loadedValue = pg->AllocReg();
@@ -169,12 +169,10 @@ static void GenObjectProperty(PandaGen *pg, const ir::ObjectExpression *object,
         key->Compile(pg);
     }
 
-    pg->StoreAccumulator(key, propReg);
-
     LReference lref = LReference::CreateLRef(pg, target, object->IsDeclaration());
 
     // load obj property from rhs, return undefined if no corresponding property exists
-    pg->LoadObjByValue(element, value, propReg);
+    pg->LoadObjByValue(element, value);
     pg->StoreAccumulator(element, loadedValue);
 
     if (init != nullptr) {
@@ -211,8 +209,7 @@ static void GenObjectWithRest(PandaGen *pg, const ir::ObjectExpression *object,
             break;
         }
 
-        VReg propReg = pg->AllocReg();
-        GenObjectProperty(pg, object, element, rhs, propReg);
+        GenObjectProperty(pg, object, element, rhs);
     }
 }
 
@@ -241,10 +238,7 @@ static void GenObject(PandaGen *pg, const ir::ObjectExpression *object, VReg rhs
     }
 
     for (const auto *element : properties) {
-        RegScope rs(pg);
-        VReg propReg = pg->AllocReg();
-
-        GenObjectProperty(pg, object, element, rhs, propReg);
+        GenObjectProperty(pg, object, element, rhs);
     }
 }
 
diff --git a/es2panda/compiler/base/hoisting.cpp b/es2panda/compiler/base/hoisting.cpp
index e8b61fc97d3252b521f595b266bd3675664f6729..5f5b6370b65be4bfa2cc4122dbe808fd3a1a6ac8 100644
--- a/es2panda/compiler/base/hoisting.cpp
+++ b/es2panda/compiler/base/hoisting.cpp
@@ -27,7 +27,9 @@ static void StoreModuleVarOrLocalVar(PandaGen *pg, binder::ScopeFindResult &resu
 {
     if (decl->IsImportOrExportDecl()) {
         ASSERT(pg->Scope()->IsModuleScope());
-        pg->StoreModuleVariable(decl->Node(), decl->Name());
+        auto *var = pg->Scope()->FindLocal(decl->Name());
+        ASSERT(var->IsModuleVariable());
+        pg->StoreModuleVariable(decl->Node(), var->AsModuleVariable());
     } else {
         pg->StoreAccToLexEnv(decl->Node(), result, true);
     }
@@ -84,7 +86,7 @@ static void HoistNameSpaceImports(PandaGen *pg)
             ASSERT(var != nullptr);
             auto *node = var->Declaration()->Node();
             ASSERT(node != nullptr);
-            pg->GetModuleNamespace(node, nameSpaceEntry->localName_);
+            pg->GetModuleNamespace(node, nameSpaceEntry->moduleRequestIdx_);
             pg->StoreVar(node, {nameSpaceEntry->localName_, pg->TopScope(), 0, var}, true);
         }
     }
diff --git a/es2panda/compiler/core/compilerContext.cpp b/es2panda/compiler/core/compilerContext.cpp
index 81434e630b0a4cdccc30fa37dc54886355150f91..f3549110db087121ab07c049dfe76cea3a76e401 100644
--- a/es2panda/compiler/core/compilerContext.cpp
+++ b/es2panda/compiler/core/compilerContext.cpp
@@ -20,9 +20,10 @@
 namespace panda::es2panda::compiler {
 
 CompilerContext::CompilerContext(binder::Binder *binder, bool isDebug, bool isDebuggerEvaluateExpressionMode,
-                                 bool isMergeAbc, std::string sourceFile)
+                                 bool isMergeAbc, std::string sourceFile, util::StringView recordName)
     : binder_(binder), isDebug_(isDebug), isDebuggerEvaluateExpressionMode_(isDebuggerEvaluateExpressionMode),
-      isMergeAbc_(isMergeAbc), sourceFile_(sourceFile), emitter_(std::make_unique<class Emitter>(this))
+      isMergeAbc_(isMergeAbc), sourceFile_(sourceFile), emitter_(std::make_unique<class Emitter>(this)),
+      recordName_(recordName)
 {
 }
 
diff --git a/es2panda/compiler/core/compilerContext.h b/es2panda/compiler/core/compilerContext.h
index 6acc7b83fb53a24cf1004237abdbab7734ca6349..5348d48fd36f327edbe0bc513932a09d4c209635 100644
--- a/es2panda/compiler/core/compilerContext.h
+++ b/es2panda/compiler/core/compilerContext.h
@@ -19,6 +19,7 @@
 #include <macros.h>
 #include <mem/arena_allocator.h>
 #include <util/hotfix.h>
+#include <util/ustring.h>
 
 #include <cstdint>
 #include <mutex>
@@ -35,7 +36,7 @@ class Emitter;
 class CompilerContext {
 public:
     CompilerContext(binder::Binder *binder, bool isDebug, bool isDebuggerEvaluateExpressionMode,
-                    bool isMergeAbc, std::string sourceFile);
+                    bool isMergeAbc, std::string sourceFile, util::StringView recordName);
     NO_COPY_SEMANTIC(CompilerContext);
     NO_MOVE_SEMANTIC(CompilerContext);
     ~CompilerContext() = default;
@@ -96,6 +97,11 @@ public:
         return hotfixHelper_;
     }
 
+    util::StringView RecordName() const
+    {
+        return recordName_;
+    }
+
 private:
     binder::Binder *binder_;
     int32_t literalBufferIdx_ {0};
@@ -106,6 +112,7 @@ private:
     std::string sourceFile_;
     std::unique_ptr<Emitter> emitter_;
     util::Hotfix *hotfixHelper_ {nullptr};
+    util::StringView recordName_;
 };
 
 }  // namespace panda::es2panda::compiler
diff --git a/es2panda/compiler/core/compilerImpl.cpp b/es2panda/compiler/core/compilerImpl.cpp
index 5561346b974793c47b68f0e8599a6c22d805f6e7..368783be9633a58dc2a8ce8f99c98582a2344101 100644
--- a/es2panda/compiler/core/compilerImpl.cpp
+++ b/es2panda/compiler/core/compilerImpl.cpp
@@ -39,7 +39,7 @@ panda::pandasm::Program *CompilerImpl::Compile(parser::Program *program, const e
     const std::string &debugInfoSourceFile)
 {
     CompilerContext context(program->Binder(), options.isDebug, options.isDebuggerEvaluateExpressionMode,
-                            options.mergeAbc, debugInfoSourceFile);
+                            options.mergeAbc, debugInfoSourceFile, program->RecordName());
 
     if (hotfixHelper_ != nullptr) {
         context.AddHotfixHelper(hotfixHelper_);
diff --git a/es2panda/compiler/core/emitter/emitter.cpp b/es2panda/compiler/core/emitter/emitter.cpp
index 53064fdc1dea20e7c450060e75a09504cadcdc15..13f1b0a41d5c9bd189e41198b8670c373111b8fd 100644
--- a/es2panda/compiler/core/emitter/emitter.cpp
+++ b/es2panda/compiler/core/emitter/emitter.cpp
@@ -57,6 +57,7 @@ FunctionEmitter::FunctionEmitter(ArenaAllocator *allocator, const PandaGen *pg)
 
 void FunctionEmitter::Generate(util::Hotfix *hotfixHelper)
 {
+    GenFunctionKind();
     GenFunctionInstructions();
     GenVariablesDebugInfo();
     GenSourceFileDebugInfo();
@@ -72,6 +73,16 @@ const ArenaSet<util::StringView> &FunctionEmitter::Strings() const
     return pg_->Strings();
 }
 
+void FunctionEmitter::GenFunctionKind()
+{
+    func_->SetFunctionKind(static_cast<panda::panda_file::FunctionKind>(pg_->GetFunctionKind()));
+}
+
+void FunctionEmitter::GenIcSize()
+{
+    func_->SetSlotsNum(pg_->GetCurrentSlot());
+}
+
 void FunctionEmitter::GenBufferLiterals(const LiteralBuffer *buff)
 {
     auto &[idx, array] = literalBuffers_.emplace_back();
diff --git a/es2panda/compiler/core/emitter/emitter.h b/es2panda/compiler/core/emitter/emitter.h
index f689a4e57c80e973f81be76d7c0064134343f076..3bf135f729da4656bed90d9673739d5ed3e30223 100644
--- a/es2panda/compiler/core/emitter/emitter.h
+++ b/es2panda/compiler/core/emitter/emitter.h
@@ -81,6 +81,8 @@ private:
     void GenScopeVariableInfo(const binder::Scope *scope);
     void GenSourceFileDebugInfo();
     void GenVariablesDebugInfo();
+    void GenFunctionKind();
+    void GenIcSize();
     util::StringView SourceCode() const;
     lexer::LineIndex &GetLineIndex() const;
 
diff --git a/es2panda/compiler/core/envScope.cpp b/es2panda/compiler/core/envScope.cpp
index a6c123937c6f11cf1f0d2398dc394504f5ebffed..6cb007c87e5599bda9ef68b52009c49f28edf250 100644
--- a/es2panda/compiler/core/envScope.cpp
+++ b/es2panda/compiler/core/envScope.cpp
@@ -30,11 +30,10 @@ ScopeContext::~ScopeContext()
     pg_->scope_ = prevScope_;
 }
 
-void EnvScope::Initialize(PandaGen *pg, VReg lexEnv)
+void EnvScope::Initialize(PandaGen *pg)
 {
     pg_ = pg;
     prev_ = pg_->envScope_;
-    lexEnv_ = lexEnv;
     pg_->envScope_ = this;
 }
 
@@ -53,10 +52,9 @@ void LoopEnvScope::CopyBindings(PandaGen *pg, binder::VariableScope *scope, bind
         return;
     }
 
-    Initialize(pg, pg->AllocReg());
+    Initialize(pg);
 
     pg_->NewLexicalEnv(scope_->Node(), scope->LexicalSlots(), scope_);
-    pg_->StoreAccumulator(scope_->Node(), lexEnv_);
 
     ASSERT(scope->NeedLexEnv());
 
@@ -89,7 +87,6 @@ void LoopEnvScope::CopyPetIterationCtx()
     }
     pg_->PopLexEnv(scope_->Node());
     pg_->NewLexicalEnv(scope_->Node(), num, scope_);
-    pg_->StoreAccumulator(scope_->Node(), lexEnv_);
 
     for (uint32_t i = 0; i < num; i++) {
         pg_->StoreLexicalVar(scope_->Node(), 0, i, lexicals[i]);
diff --git a/es2panda/compiler/core/envScope.h b/es2panda/compiler/core/envScope.h
index 55b801a7a1f3e026a9403344d896fdbedc68ecbe..a21c2a3e52022a8ec6e51467b395d410cda5f5e8 100644
--- a/es2panda/compiler/core/envScope.h
+++ b/es2panda/compiler/core/envScope.h
@@ -52,12 +52,7 @@ public:
     NO_MOVE_SEMANTIC(EnvScope);
     ~EnvScope();
 
-    void Initialize(PandaGen *pg, VReg lexEnv);
-
-    VReg LexEnv() const
-    {
-        return lexEnv_;
-    }
+    void Initialize(PandaGen *pg);
 
     EnvScope *Prev() const
     {
@@ -69,7 +64,6 @@ protected:
 
     PandaGen *pg_ {};
     EnvScope *prev_ {};
-    VReg lexEnv_ {};
 };
 
 class LoopEnvScope : public EnvScope {
diff --git a/es2panda/compiler/core/function.cpp b/es2panda/compiler/core/function.cpp
index 3f4a050ea07cc44fde3dc3c1d3779b8e2fdf6b89..1df946cfa6ad5c3f0fa3eab99962806bb159d67b 100644
--- a/es2panda/compiler/core/function.cpp
+++ b/es2panda/compiler/core/function.cpp
@@ -170,7 +170,7 @@ static void CompileFunction(PandaGen *pg)
     pg->FunctionExit();
 }
 
-static VReg CompileFunctionOrProgram(PandaGen *pg)
+static void CompileFunctionOrProgram(PandaGen *pg)
 {
     FunctionRegScope lrs(pg);
     const auto *topScope = pg->TopScope();
@@ -192,16 +192,15 @@ static VReg CompileFunctionOrProgram(PandaGen *pg)
             CompileSourceBlock(pg, pg->RootNode()->AsBlockStatement());
         }
     }
-
-    return pg->GetEnvScope()->LexEnv();
 }
 
 void Function::Compile(PandaGen *pg)
 {
-    VReg lexEnv = CompileFunctionOrProgram(pg);
+    CompileFunctionOrProgram(pg);
+    pg->SetFunctionKind();
     pg->SetSourceLocationFlag(lexer::SourceLocationFlag::INVALID_SOURCE_LOCATION);
     pg->CopyFunctionArguments(pg->RootNode());
-    pg->InitializeLexEnv(pg->RootNode(), lexEnv);
+    pg->InitializeLexEnv(pg->RootNode());
     pg->SetSourceLocationFlag(lexer::SourceLocationFlag::VALID_SOURCE_LOCATION);
     pg->SortCatchTables();
 }
diff --git a/es2panda/compiler/core/pandagen.cpp b/es2panda/compiler/core/pandagen.cpp
index e56e28c72dc42d6fc0fdc2f07c3049f0955913d6..b9a4616bf56784ae53c2a83bdb3489309f50dced 100644
--- a/es2panda/compiler/core/pandagen.cpp
+++ b/es2panda/compiler/core/pandagen.cpp
@@ -42,11 +42,52 @@
 #include <ir/expressions/literals/stringLiteral.h>
 #include <ir/expressions/newExpression.h>
 #include <ir/statement.h>
+#include <util/helpers.h>
 
 namespace panda::es2panda::compiler {
 
 // PandaGen
 
+void PandaGen::SetFunctionKind()
+{
+    if (rootNode_->IsProgram()) {
+        funcKind_ = FunctionKind::FUNCTION;
+        return;
+    }
+
+    auto *func = rootNode_->AsScriptFunction();
+    if (func->IsMethod()) {
+        return;
+    }
+
+    if (func->IsAsync()) {
+        if (func->IsGenerator()) {
+            funcKind_ = FunctionKind::ASYNC_GENERATOR_FUNCTION;
+            return;
+        }
+
+        if (func->IsArrow()) {
+            funcKind_ = FunctionKind::ASYNC_NCFUNCTION;
+            return;
+        }
+
+        funcKind_ = FunctionKind::ASYNC_FUNCTION;
+        return;
+    }
+
+    if (func->IsGenerator()) {
+        funcKind_ = FunctionKind::GENERATOR_FUNCTION;
+        return;
+    }
+
+    if (func->IsArrow()) {
+        funcKind_ = FunctionKind::NC_FUNCTION;
+        return;
+    }
+
+    funcKind_ = FunctionKind::FUNCTION;
+}
+
 Label *PandaGen::AllocLabel()
 {
     std::string id = std::string {Label::PREFIX} + std::to_string(labelId_++);
@@ -157,17 +198,13 @@ void PandaGen::FunctionExit()
     builder_->CleanUp(rootNode_->AsScriptFunction());
 }
 
-void PandaGen::InitializeLexEnv(const ir::AstNode *node, VReg lexEnv)
+void PandaGen::InitializeLexEnv(const ir::AstNode *node)
 {
     FrontAllocator fa(this);
 
     if (topScope_->NeedLexEnv()) {
         NewLexicalEnv(node, topScope_->LexicalSlots(), topScope_);
-    } else {
-        LdLexEnv(node);
     }
-
-    StoreAccumulator(node, lexEnv);
 }
 
 void PandaGen::CopyFunctionArguments(const ir::AstNode *node)
@@ -179,7 +216,7 @@ void PandaGen::CopyFunctionArguments(const ir::AstNode *node)
         if (param->LexicalBound()) {
             StoreLexicalVar(node, 0, param->LexIdx(), targetReg++);
         } else {
-            ra_.Emit<MovDyn>(node, param->Vreg(), targetReg++);
+            MoveVreg(node, param->Vreg(), targetReg++);
         }
     }
 }
@@ -242,7 +279,8 @@ void PandaGen::LoadVar(const ir::Identifier *node, const binder::ScopeFindResult
     }
 
     if (var->IsModuleVariable()) {
-        LoadModuleVariable(node, var->Name(), var->HasFlag(binder::VariableFlags::LOCAL_EXPORT));
+        var->HasFlag(binder::VariableFlags::LOCAL_EXPORT) ? LoadLocalModuleVariable(node, var->AsModuleVariable()) :
+                                                            LoadExternalModuleVariable(node, var->AsModuleVariable());
         if (var->Declaration()->IsLetOrConstOrClassDecl()) {
             ThrowUndefinedIfHole(node, var->Name());
         }
@@ -284,12 +322,12 @@ void PandaGen::StoreVar(const ir::AstNode *node, const binder::ScopeFindResult &
             RegScope rs(this);
             VReg valueReg = AllocReg();
             StoreAccumulator(node, valueReg);
-            LoadModuleVariable(node, var->Name(), true);
+            LoadLocalModuleVariable(node, var->AsModuleVariable());
             ThrowUndefinedIfHole(node, var->Name());
             LoadAccumulator(node, valueReg);
         }
 
-        StoreModuleVariable(node, var->Name());
+        StoreModuleVariable(node, var->AsModuleVariable());
         return;
     }
 
@@ -298,13 +336,12 @@ void PandaGen::StoreVar(const ir::AstNode *node, const binder::ScopeFindResult &
     if (var->Declaration()->IsLetOrConstOrClassDecl() && result.scope->IsGlobalScope()) {
         if (!isDeclaration) {
             TryStoreGlobalByName(node, var->Name());
-        } else if (var->Declaration()->IsLetDecl()) {
-            StLetToGlobalRecord(node, var->Name());
+        } else if (var->Declaration()->IsLetDecl() || var->Declaration()->IsClassDecl()) {
+            StLetOrClassToGlobalRecord(node, var->Name());
         } else if (var->Declaration()->IsConstDecl()) {
             StConstToGlobalRecord(node, var->Name());
-        } else if (var->Declaration()->IsClassDecl()) {
-            StClassToGlobalRecord(node, var->Name());
         }
+
         return;
     }
 
@@ -313,7 +350,7 @@ void PandaGen::StoreVar(const ir::AstNode *node, const binder::ScopeFindResult &
 
 void PandaGen::StoreAccumulator(const ir::AstNode *node, VReg vreg)
 {
-    ra_.Emit<StaDyn>(node, vreg);
+    ra_.Emit<Sta>(node, vreg);
 }
 
 void PandaGen::LoadAccFromArgs(const ir::AstNode *node)
@@ -334,7 +371,8 @@ void PandaGen::LoadAccFromArgs(const ir::AstNode *node)
 void PandaGen::LoadObjProperty(const ir::AstNode *node, VReg obj, const Operand &prop)
 {
     if (std::holds_alternative<VReg>(prop)) {
-        LoadObjByValue(node, obj, std::get<VReg>(prop));
+        LoadAccumulator(node, std::get<VReg>(prop));
+        LoadObjByValue(node, obj);
         return;
     }
 
@@ -409,7 +447,8 @@ void PandaGen::TryLoadGlobalByName(const ir::AstNode *node, const util::StringVi
     if (isDebuggerEvaluateExpressionMode()) {
         LoadObjByNameViaDebugger(node, name, true);
     } else {
-        sa_.Emit<EcmaTryldglobalbyname>(node, name);
+        // modify ic later
+        sa_.Emit<Tryldglobalbyname>(node, 0, name);
     }
     strings_.insert(name);
 }
@@ -437,109 +476,121 @@ void PandaGen::TryStoreGlobalByName(const ir::AstNode *node, const util::StringV
     if (isDebuggerEvaluateExpressionMode()) {
         StoreObjByNameViaDebugger(node, name);
     } else {
-        sa_.Emit<EcmaTrystglobalbyname>(node, name);
+        // modify ic later
+        sa_.Emit<Trystglobalbyname>(node, 0, name);
     }
     strings_.insert(name);
 }
 
 void PandaGen::LoadObjByName(const ir::AstNode *node, VReg obj, const util::StringView &prop)
 {
-    ra_.Emit<EcmaLdobjbyname>(node, prop, obj);
+    // modify ic later
+    LoadAccumulator(node, obj); // object is load to acc
+    sa_.Emit<Ldobjbyname>(node, 0, prop);
     strings_.insert(prop);
 }
 
 void PandaGen::StoreObjByName(const ir::AstNode *node, VReg obj, const util::StringView &prop)
 {
-    ra_.Emit<EcmaStobjbyname>(node, prop, obj);
+    // modify ic later
+    ra_.Emit<Stobjbyname>(node, 0, prop, obj);
     strings_.insert(prop);
 }
 
 void PandaGen::LoadObjByIndex(const ir::AstNode *node, VReg obj, int64_t index)
 {
-    ra_.Emit<EcmaLdobjbyindex>(node, index, obj);
+    LoadAccumulator(node, obj); // object is load to acc
+    if (index <= util::Helpers::MAX_INT16) {
+        // modify ic later
+        sa_.Emit<Ldobjbyindex>(node, 0, index);
+        return;
+    }
+
+    sa_.Emit<WideLdobjbyindex>(node, index);
 }
 
-void PandaGen::LoadObjByValue(const ir::AstNode *node, VReg obj, VReg prop)
+void PandaGen::LoadObjByValue(const ir::AstNode *node, VReg obj)
 {
-    ra_.Emit<EcmaLdobjbyvalue>(node, obj, prop);
+    // modify ic later
+    ra_.Emit<Ldobjbyvalue>(node, 0, obj); // prop is in acc
 }
 
 void PandaGen::StoreObjByValue(const ir::AstNode *node, VReg obj, VReg prop)
 {
-    ra_.Emit<EcmaStobjbyvalue>(node, obj, prop);
+    // modify ic later
+    ra_.Emit<Stobjbyvalue>(node, 0, obj, prop);
 }
 
 void PandaGen::StoreObjByIndex(const ir::AstNode *node, VReg obj, int64_t index)
 {
-    ra_.Emit<EcmaStobjbyindex>(node, index, obj);
+    if (index <= util::Helpers::MAX_INT16) {
+        // modify ic later
+        ra_.Emit<Stobjbyindex>(node, 0, obj, index);
+        return;
+    }
+
+    ra_.Emit<WideStobjbyindex>(node, obj, index);
 }
 
 void PandaGen::StOwnByName(const ir::AstNode *node, VReg obj, const util::StringView &prop, bool nameSetting)
 {
-    nameSetting ? ra_.Emit<EcmaStownbynamewithnameset>(node, prop, obj) :
-                  ra_.Emit<EcmaStownbyname>(node, prop, obj);
+    // modify ic later
+    nameSetting ? ra_.Emit<Stownbynamewithnameset>(node, 0, prop, obj) :
+                  ra_.Emit<Stownbyname>(node, 0, prop, obj);
     strings_.insert(prop);
 }
 
 void PandaGen::StOwnByValue(const ir::AstNode *node, VReg obj, VReg prop, bool nameSetting)
 {
-    nameSetting ? ra_.Emit<EcmaStownbyvaluewithnameset>(node, obj, prop) :
-                  ra_.Emit<EcmaStownbyvalue>(node, obj, prop);
+    // modify ic later
+    nameSetting ? ra_.Emit<Stownbyvaluewithnameset>(node, 0, obj, prop) :
+                  ra_.Emit<Stownbyvalue>(node, 0, obj, prop);
 }
 
 void PandaGen::StOwnByIndex(const ir::AstNode *node, VReg obj, int64_t index)
 {
-    ra_.Emit<EcmaStownbyindex>(node, obj, index);
+    if (index <= util::Helpers::MAX_INT16) {
+        // modify ic later
+        ra_.Emit<Stownbyindex>(node, 0, obj, index);
+        return;
+    }
+
+    ra_.Emit<WideStownbyindex>(node, obj, index);
 }
 
 void PandaGen::DeleteObjProperty(const ir::AstNode *node, VReg obj, const Operand &prop)
 {
-    VReg property {};
-
     if (std::holds_alternative<VReg>(prop)) {
-        property = std::get<VReg>(prop);
+        LoadAccumulator(node, std::get<VReg>(prop));
     } else if (std::holds_alternative<int64_t>(prop)) {
         LoadAccumulatorInt(node, static_cast<size_t>(std::get<int64_t>(prop)));
-        property = AllocReg();
-        StoreAccumulator(node, property);
     } else {
         ASSERT(std::holds_alternative<util::StringView>(prop));
         LoadAccumulatorString(node, std::get<util::StringView>(prop));
-        property = AllocReg();
-        StoreAccumulator(node, property);
     }
 
-    ra_.Emit<EcmaDelobjprop>(node, obj, property);
+    ra_.Emit<Delobjprop>(node, obj); // property is load to acc
 }
 
 void PandaGen::LoadAccumulator(const ir::AstNode *node, VReg reg)
 {
-    ra_.Emit<LdaDyn>(node, reg);
+    ra_.Emit<Lda>(node, reg);
 }
 
 void PandaGen::LoadGlobalVar(const ir::AstNode *node, const util::StringView &name)
 {
-    sa_.Emit<EcmaLdglobalvar>(node, name);
+    // modify ic later
+    sa_.Emit<Ldglobalvar>(node, 0, name);
     strings_.insert(name);
 }
 
 void PandaGen::StoreGlobalVar(const ir::AstNode *node, const util::StringView &name)
 {
-    sa_.Emit<EcmaStglobalvar>(node, name);
-    strings_.insert(name);
-}
-
-void PandaGen::StoreGlobalLet(const ir::AstNode *node, const util::StringView &name)
-{
-    sa_.Emit<EcmaStglobalvar>(node, name);
+    // modify ic later
+    sa_.Emit<Stglobalvar>(node, 0, name);
     strings_.insert(name);
 }
 
-VReg PandaGen::LexEnv() const
-{
-    return envScope_->LexEnv();
-}
-
 void PandaGen::LoadAccFromLexEnv(const ir::AstNode *node, const binder::ScopeFindResult &result)
 {
     VirtualLoadVar::Expand(this, node, result);
@@ -558,22 +609,22 @@ void PandaGen::LoadAccumulatorString(const ir::AstNode *node, const util::String
 
 void PandaGen::LoadAccumulatorFloat(const ir::AstNode *node, double num)
 {
-    sa_.Emit<FldaiDyn>(node, num);
+    sa_.Emit<Fldai>(node, num);
 }
 
 void PandaGen::LoadAccumulatorInt(const ir::AstNode *node, int32_t num)
 {
-    sa_.Emit<LdaiDyn>(node, num);
+    sa_.Emit<Ldai>(node, num);
 }
 
 void PandaGen::LoadAccumulatorInt(const ir::AstNode *node, size_t num)
 {
-    sa_.Emit<LdaiDyn>(node, static_cast<int64_t>(num));
+    sa_.Emit<Ldai>(node, static_cast<int64_t>(num));
 }
 
 void PandaGen::LoadAccumulatorBigInt(const ir::AstNode *node, const util::StringView &num)
 {
-    sa_.Emit<EcmaLdbigint>(node, num);
+    sa_.Emit<Ldbigint>(node, num);
     strings_.insert(num);
 }
 
@@ -587,39 +638,39 @@ void PandaGen::LoadConst(const ir::AstNode *node, Constant id)
 {
     switch (id) {
         case Constant::JS_HOLE: {
-            sa_.Emit<EcmaLdhole>(node);
+            sa_.Emit<Ldhole>(node);
             break;
         }
         case Constant::JS_NAN: {
-            sa_.Emit<EcmaLdnan>(node);
+            sa_.Emit<Ldnan>(node);
             break;
         }
         case Constant::JS_INFINITY: {
-            sa_.Emit<EcmaLdinfinity>(node);
+            sa_.Emit<Ldinfinity>(node);
             break;
         }
         case Constant::JS_GLOBAL: {
-            sa_.Emit<EcmaLdglobal>(node);
+            sa_.Emit<Ldglobal>(node);
             break;
         }
         case Constant::JS_UNDEFINED: {
-            sa_.Emit<EcmaLdundefined>(node);
+            sa_.Emit<Ldundefined>(node);
             break;
         }
         case Constant::JS_SYMBOL: {
-            sa_.Emit<EcmaLdsymbol>(node);
+            sa_.Emit<Ldsymbol>(node);
             break;
         }
         case Constant::JS_NULL: {
-            sa_.Emit<EcmaLdnull>(node);
+            sa_.Emit<Ldnull>(node);
             break;
         }
         case Constant::JS_TRUE: {
-            sa_.Emit<EcmaLdtrue>(node);
+            sa_.Emit<Ldtrue>(node);
             break;
         }
         case Constant::JS_FALSE: {
-            sa_.Emit<EcmaLdfalse>(node);
+            sa_.Emit<Ldfalse>(node);
             break;
         }
         default: {
@@ -630,7 +681,7 @@ void PandaGen::LoadConst(const ir::AstNode *node, Constant id)
 
 void PandaGen::MoveVreg(const ir::AstNode *node, VReg vd, VReg vs)
 {
-    ra_.Emit<MovDyn>(node, vd, vs);
+    ra_.Emit<Mov>(node, vd, vs);
 }
 
 void PandaGen::SetLabel([[maybe_unused]] const ir::AstNode *node, Label *label)
@@ -713,35 +764,35 @@ void PandaGen::Condition(const ir::AstNode *node, lexer::TokenType op, VReg lhs,
 {
     switch (op) {
         case lexer::TokenType::PUNCTUATOR_EQUAL: {
-            ra_.Emit<EcmaEqdyn>(node, lhs);
+            Equal(node, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_NOT_EQUAL: {
-            ra_.Emit<EcmaNoteqdyn>(node, lhs);
+            NotEqual(node, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_STRICT_EQUAL: {
-            ra_.Emit<EcmaStricteqdyn>(node, lhs);
+            StrictEqual(node, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL: {
-            ra_.Emit<EcmaStrictnoteqdyn>(node, lhs);
+            StrictNotEqual(node, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_LESS_THAN: {
-            ra_.Emit<EcmaLessdyn>(node, lhs);
+            LessThan(node, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_LESS_THAN_EQUAL: {
-            ra_.Emit<EcmaLesseqdyn>(node, lhs);
+            LessEqual(node, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_GREATER_THAN: {
-            ra_.Emit<EcmaGreaterdyn>(node, lhs);
+            GreaterThan(node, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_GREATER_THAN_EQUAL: {
-            ra_.Emit<EcmaGreatereqdyn>(node, lhs);
+            GreaterEqual(node, lhs);
             break;
         }
         default: {
@@ -756,15 +807,17 @@ void PandaGen::Unary(const ir::AstNode *node, lexer::TokenType op, VReg operand)
 {
     switch (op) {
         case lexer::TokenType::PUNCTUATOR_PLUS: {
-            ra_.Emit<EcmaTonumber>(node, operand);
+            ToNumber(node, operand);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_MINUS: {
-            ra_.Emit<EcmaNegdyn>(node, operand);
+            LoadAccumulator(node, operand);
+            sa_.Emit<Neg>(node, 0);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_TILDE: {
-            ra_.Emit<EcmaNotdyn>(node, operand);
+            LoadAccumulator(node, operand);
+            sa_.Emit<Not>(node, 0);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_EXCLAMATION_MARK: {
@@ -772,11 +825,13 @@ void PandaGen::Unary(const ir::AstNode *node, lexer::TokenType op, VReg operand)
             break;
         }
         case lexer::TokenType::PUNCTUATOR_PLUS_PLUS: {
-            ra_.Emit<EcmaIncdyn>(node, operand);
+            LoadAccumulator(node, operand);
+            sa_.Emit<Inc>(node, 0);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_MINUS_MINUS: {
-            ra_.Emit<EcmaDecdyn>(node, operand);
+            LoadAccumulator(node, operand);
+            sa_.Emit<Dec>(node, 0);
             break;
         }
         case lexer::TokenType::KEYW_VOID:
@@ -792,105 +847,106 @@ void PandaGen::Unary(const ir::AstNode *node, lexer::TokenType op, VReg operand)
 
 void PandaGen::Binary(const ir::AstNode *node, lexer::TokenType op, VReg lhs)
 {
+    // modify ic later
     switch (op) {
         case lexer::TokenType::PUNCTUATOR_EQUAL: {
-            ra_.Emit<EcmaEqdyn>(node, lhs);
+            Equal(node, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_NOT_EQUAL: {
-            ra_.Emit<EcmaNoteqdyn>(node, lhs);
+            NotEqual(node, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_STRICT_EQUAL: {
-            ra_.Emit<EcmaStricteqdyn>(node, lhs);
+            StrictEqual(node, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL: {
-            ra_.Emit<EcmaStrictnoteqdyn>(node, lhs);
+            StrictNotEqual(node, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_LESS_THAN: {
-            ra_.Emit<EcmaLessdyn>(node, lhs);
+            LessThan(node, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_LESS_THAN_EQUAL: {
-            ra_.Emit<EcmaLesseqdyn>(node, lhs);
+            LessEqual(node, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_GREATER_THAN: {
-            ra_.Emit<EcmaGreaterdyn>(node, lhs);
+            GreaterThan(node, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_GREATER_THAN_EQUAL: {
-            ra_.Emit<EcmaGreatereqdyn>(node, lhs);
+            GreaterEqual(node, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_PLUS:
         case lexer::TokenType::PUNCTUATOR_PLUS_EQUAL: {
-            ra_.Emit<EcmaAdd2dyn>(node, lhs);
+            ra_.Emit<Add2>(node, 0, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_MINUS:
         case lexer::TokenType::PUNCTUATOR_MINUS_EQUAL: {
-            ra_.Emit<EcmaSub2dyn>(node, lhs);
+            ra_.Emit<Sub2>(node, 0, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_MULTIPLY:
         case lexer::TokenType::PUNCTUATOR_MULTIPLY_EQUAL: {
-            ra_.Emit<EcmaMul2dyn>(node, lhs);
+            ra_.Emit<Mul2>(node, 0, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_DIVIDE:
         case lexer::TokenType::PUNCTUATOR_DIVIDE_EQUAL: {
-            ra_.Emit<EcmaDiv2dyn>(node, lhs);
+            ra_.Emit<Div2>(node, 0, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_MOD:
         case lexer::TokenType::PUNCTUATOR_MOD_EQUAL: {
-            ra_.Emit<EcmaMod2dyn>(node, lhs);
+            ra_.Emit<Mod2>(node, 0, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_EXPONENTIATION_EQUAL:
         case lexer::TokenType::PUNCTUATOR_EXPONENTIATION: {
-            ra_.Emit<EcmaExpdyn>(node, lhs);
+            ra_.Emit<Exp>(node, 0, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_LEFT_SHIFT:
         case lexer::TokenType::PUNCTUATOR_LEFT_SHIFT_EQUAL: {
-            ra_.Emit<EcmaShl2dyn>(node, lhs);
+            ra_.Emit<Shl2>(node, 0, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT:
         case lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT_EQUAL: {
-            ra_.Emit<EcmaShr2dyn>(node, lhs);
+            ra_.Emit<Ashr2>(node, 0, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT:
         case lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT_EQUAL: {
-            ra_.Emit<EcmaAshr2dyn>(node, lhs);
+            ra_.Emit<Shr2>(node, 0, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_BITWISE_AND:
         case lexer::TokenType::PUNCTUATOR_BITWISE_AND_EQUAL: {
-            ra_.Emit<EcmaAnd2dyn>(node, lhs);
+            ra_.Emit<And2>(node, 0, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_BITWISE_OR:
         case lexer::TokenType::PUNCTUATOR_BITWISE_OR_EQUAL: {
-            ra_.Emit<EcmaOr2dyn>(node, lhs);
+            ra_.Emit<Or2>(node, 0, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_BITWISE_XOR:
         case lexer::TokenType::PUNCTUATOR_BITWISE_XOR_EQUAL: {
-            ra_.Emit<EcmaXor2dyn>(node, lhs);
+            ra_.Emit<Xor2>(node, 0, lhs);
             break;
         }
         case lexer::TokenType::KEYW_IN: {
-            ra_.Emit<EcmaIsindyn>(node, lhs);
+            ra_.Emit<Isin>(node, 0, lhs);
             break;
         }
         case lexer::TokenType::KEYW_INSTANCEOF: {
-            ra_.Emit<EcmaInstanceofdyn>(node, lhs);
+            ra_.Emit<Instanceof>(node, 0, lhs);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_NULLISH_COALESCING:
@@ -904,13 +960,66 @@ void PandaGen::Binary(const ir::AstNode *node, lexer::TokenType op, VReg lhs)
     }
 }
 
+void PandaGen::Equal(const ir::AstNode *node, VReg lhs)
+{
+    // modify ic later
+    ra_.Emit<Eq>(node, 0, lhs);
+}
+
+void PandaGen::NotEqual(const ir::AstNode *node, VReg lhs)
+{
+    // modify ic later
+    ra_.Emit<Noteq>(node, 0, lhs);
+}
+
+void PandaGen::StrictEqual(const ir::AstNode *node, VReg lhs)
+{
+    // modify ic later
+    ra_.Emit<Stricteq>(node, 0, lhs);
+}
+
+void PandaGen::StrictNotEqual(const ir::AstNode *node, VReg lhs)
+{
+    // modify ic later
+    ra_.Emit<Strictnoteq>(node, 0, lhs);
+}
+
+void PandaGen::LessThan(const ir::AstNode *node, VReg lhs)
+{
+    // modify ic later
+    ra_.Emit<Less>(node, 0, lhs);
+}
+
+void PandaGen::LessEqual(const ir::AstNode *node, VReg lhs)
+{
+    // modify ic later
+    ra_.Emit<Lesseq>(node, 0, lhs);
+}
+
+void PandaGen::GreaterThan(const ir::AstNode *node, VReg lhs)
+{
+    // modify ic later
+    ra_.Emit<Greater>(node, 0, lhs);
+}
+
+void PandaGen::GreaterEqual(const ir::AstNode *node, VReg lhs)
+{
+    // modify ic later
+    ra_.Emit<Greatereq>(node, 0, lhs);
+}
+
+void PandaGen::IsTrue(const ir::AstNode *node)
+{
+    sa_.Emit<Istrue>(node);
+}
+
 void PandaGen::BranchIfUndefined(const ir::AstNode *node, Label *target)
 {
     RegScope rs(this);
     VReg tmp = AllocReg();
     StoreAccumulator(node, tmp);
-    sa_.Emit<EcmaLdundefined>(node);
-    ra_.Emit<EcmaEqdyn>(node, tmp);
+    LoadConst(node, Constant::JS_UNDEFINED);
+    Equal(node, tmp);
     sa_.Emit<Jnez>(node, target);
 }
 
@@ -919,8 +1028,8 @@ void PandaGen::BranchIfNotUndefined(const ir::AstNode *node, Label *target)
     RegScope rs(this);
     VReg tmp = AllocReg();
     StoreAccumulator(node, tmp);
-    sa_.Emit<EcmaLdundefined>(node);
-    ra_.Emit<EcmaEqdyn>(node, tmp);
+    LoadConst(node, Constant::JS_UNDEFINED);
+    Equal(node, tmp);
     sa_.Emit<Jeqz>(node, target);
 }
 
@@ -930,31 +1039,31 @@ void PandaGen::BranchIfStrictNotUndefined(const ir::AstNode *node, class Label *
     VReg tmp = AllocReg();
     StoreAccumulator(node, tmp);
     LoadConst(node, Constant::JS_UNDEFINED);
-    ra_.Emit<EcmaStricteqdyn>(node, tmp);
+    StrictEqual(node, tmp);
     sa_.Emit<Jeqz>(node, target);
 }
 
 void PandaGen::BranchIfTrue(const ir::AstNode *node, Label *target)
 {
-    sa_.Emit<EcmaIstrue>(node);
+    IsTrue(node);
     sa_.Emit<Jnez>(node, target);
 }
 
 void PandaGen::BranchIfNotTrue(const ir::AstNode *node, Label *target)
 {
-    sa_.Emit<EcmaIstrue>(node);
+    IsTrue(node);
     BranchIfFalse(node, target);
 }
 
 void PandaGen::BranchIfFalse(const ir::AstNode *node, Label *target)
 {
-    sa_.Emit<EcmaIsfalse>(node);
+    sa_.Emit<Isfalse>(node);
     sa_.Emit<Jnez>(node, target);
 }
 
 void PandaGen::EmitThrow(const ir::AstNode *node)
 {
-    sa_.Emit<EcmaThrowdyn>(node);
+    sa_.Emit<Throw>(node);
 }
 
 void PandaGen::EmitRethrow(const ir::AstNode *node)
@@ -970,24 +1079,24 @@ void PandaGen::EmitRethrow(const ir::AstNode *node)
     StoreConst(node, hole, Constant::JS_HOLE);
 
     LoadAccumulator(node, exception);
-    ra_.Emit<EcmaNoteqdyn>(node, hole);
+    NotEqual(node, hole);
     sa_.Emit<Jeqz>(node, skipThrow);
 
     SetLabel(node, doThrow);
     LoadAccumulator(node, exception);
-    sa_.Emit<EcmaThrowdyn>(node);
+    EmitThrow(node);
 
     SetLabel(node, skipThrow);
 }
 
 void PandaGen::EmitReturn(const ir::AstNode *node)
 {
-    sa_.Emit<ReturnDyn>(node);
+    sa_.Emit<Return>(node);
 }
 
 void PandaGen::EmitReturnUndefined(const ir::AstNode *node)
 {
-    sa_.Emit<EcmaReturnundefined>(node);
+    sa_.Emit<Returnundefined>(node);
 }
 
 void PandaGen::ImplicitReturn(const ir::AstNode *node)
@@ -1033,38 +1142,80 @@ void PandaGen::EmitAwait(const ir::AstNode *node)
 
 void PandaGen::CallThis(const ir::AstNode *node, VReg startReg, size_t argCount)
 {
-    rra_.Emit<EcmaCallithisrangedyn>(node, startReg, argCount + 2, static_cast<int64_t>(argCount), startReg);
+    // modify ic later
+    LoadAccumulator(node, startReg); // callee is load to acc
+    VReg thisReg = startReg + 1;
+    switch (argCount) {
+        case 1: { // no args
+            ra_.Emit<Callthis0>(node, 0, thisReg);
+            break;
+        }
+        case 2: { // 1 arg
+            VReg arg0 = thisReg + 1;
+            ra_.Emit<Callthis1>(node, 0, thisReg, arg0);
+            break;
+        }
+        case 3: { // 2 args
+            VReg arg0 = thisReg + 1;
+            VReg arg1 = arg0 + 1;
+            ra_.Emit<Callthis2>(node, 0, thisReg , arg0, arg1);
+            break;
+        }
+        case 4: { // 3 args
+            VReg arg0 = thisReg + 1;
+            VReg arg1 = arg0 + 1;
+            VReg arg2 = arg1 + 1;
+            ra_.Emit<Callthis3>(node, 0, thisReg , arg0, arg1, arg2);
+            break;
+        }
+        default: {
+            int64_t actualArgs = argCount - 1;
+            if (actualArgs <= util::Helpers::MAX_INT8) {
+                rra_.Emit<Callthisrange>(node, thisReg, argCount + 1, 0, actualArgs, thisReg);
+                break;
+            }
+
+            rra_.Emit<WideCallthisrange>(node, thisReg, argCount + 1, actualArgs, thisReg);
+            break;
+        }
+    }
 }
 
 void PandaGen::Call(const ir::AstNode *node, VReg startReg, size_t argCount)
 {
-    VReg callee = startReg;
-
+    LoadAccumulator(node, startReg); // callee is load to acc
+    // modify ic later
     switch (argCount) {
         case 0: { // 0 args
-            ra_.Emit<EcmaCallarg0dyn>(node, callee);
+            sa_.Emit<Callarg0>(node, 0);
             break;
         }
         case 1: { // 1 arg
-            VReg arg0 = callee + 1;
-            ra_.Emit<EcmaCallarg1dyn>(node, callee, arg0);
+            VReg arg0 = startReg + 1;
+            ra_.Emit<Callarg1>(node, 0, arg0);
             break;
         }
         case 2: { // 2 args
-            VReg arg0 = callee + 1;
+            VReg arg0 = startReg + 1;
             VReg arg1 = arg0 + 1;
-            ra_.Emit<EcmaCallargs2dyn>(node, callee, arg0, arg1);
+            ra_.Emit<Callargs2>(node, 0, arg0, arg1);
             break;
         }
         case 3: { // 3 args
-            VReg arg0 = callee + 1;
+            VReg arg0 = startReg + 1;
             VReg arg1 = arg0 + 1;
             VReg arg2 = arg1 + 1;
-            ra_.Emit<EcmaCallargs3dyn>(node, callee, arg0, arg1, arg2);
+            ra_.Emit<Callargs3>(node, 0, arg0, arg1, arg2);
             break;
         }
         default: {
-            rra_.Emit<EcmaCallirangedyn>(node, startReg, argCount + 1, static_cast<int64_t>(argCount), startReg);
+            VReg arg0 = startReg + 1;
+            if (argCount <= util::Helpers::MAX_INT8) {
+                rra_.Emit<Callrange>(node, arg0, argCount, 0, argCount, arg0);
+                break;
+            }
+
+            rra_.Emit<WideCallrange>(node, arg0, argCount, argCount, arg0);
             break;
         }
     }
@@ -1072,22 +1223,41 @@ void PandaGen::Call(const ir::AstNode *node, VReg startReg, size_t argCount)
 
 void PandaGen::SuperCall(const ir::AstNode *node, VReg startReg, size_t argCount)
 {
-    rra_.Emit<EcmaSupercall>(node, startReg, argCount, static_cast<int64_t>(argCount), startReg);
+    // modify ic later
+    if (RootNode()->IsArrowFunctionExpression()) {
+        GetFunctionObject(node); // load funcobj to acc for super call in arrow function
+        if (argCount <= util::Helpers::MAX_INT8) {
+            rra_.Emit<Supercallarrowrange>(node, startReg, argCount, 0, static_cast<int64_t>(argCount), startReg);
+        } else {
+            rra_.Emit<WideSupercallarrowrange>(node, startReg, argCount, static_cast<int64_t>(argCount), startReg);
+        }
+        return;
+    }
+
+    if (argCount <= util::Helpers::MAX_INT8) {
+        // no need to load funcobj to acc for super call in other kinds of functions
+        rra_.Emit<Supercallthisrange>(node, startReg, argCount, 0, static_cast<int64_t>(argCount), startReg);
+        return;
+    }
+
+    rra_.Emit<WideSupercallthisrange>(node, startReg, argCount, static_cast<int64_t>(argCount), startReg);
 }
 
 void PandaGen::SuperCallSpread(const ir::AstNode *node, VReg vs)
 {
-    ra_.Emit<EcmaSupercallspread>(node, vs);
+    // modify ic later
+    ra_.Emit<Supercallspread>(node, 0, vs);
 }
 
 void PandaGen::NewObject(const ir::AstNode *node, VReg startReg, size_t argCount)
 {
-    rra_.Emit<EcmaNewobjdynrange>(node, startReg, argCount, static_cast<int64_t>(argCount), startReg);
-}
+    if (argCount <= util::Helpers::MAX_INT8) {
+        // modify ic later
+        rra_.Emit<Newobjrange>(node, startReg, argCount, 0, static_cast<int64_t>(argCount), startReg);
+        return;
+    }
 
-void PandaGen::LoadHomeObject(const ir::AstNode *node)
-{
-    sa_.Emit<EcmaLdhomeobject>(node);
+    rra_.Emit<WideNewobjrange>(node, startReg, argCount, static_cast<int64_t>(argCount), startReg);
 }
 
 void PandaGen::DefineFunction(const ir::AstNode *node, const ir::ScriptFunction *realNode, const util::StringView &name)
@@ -1096,22 +1266,12 @@ void PandaGen::DefineFunction(const ir::AstNode *node, const ir::ScriptFunction
         return;
     }
 
+    // modify ic later
     auto formalParamCnt = realNode->FormalParamsLength();
     if (realNode->IsMethod()) {
-        ra_.Emit<EcmaDefinemethod>(node, name, static_cast<int64_t>(formalParamCnt), LexEnv());
-    } else if (realNode->IsAsync()) {
-        if (realNode->IsGenerator()) {
-            // TODO(): async generator
-        } else {
-            ra_.Emit<EcmaDefineasyncfunc>(node, name, static_cast<int64_t>(formalParamCnt), LexEnv());
-        }
-    } else if (realNode->IsGenerator()) {
-        ra_.Emit<EcmaDefinegeneratorfunc>(node, name, static_cast<int64_t>(formalParamCnt), LexEnv());
-    } else if (realNode->IsArrow()) {
-        LoadHomeObject(node);
-        ra_.Emit<EcmaDefinencfuncdyn>(node, name, static_cast<int64_t>(formalParamCnt), LexEnv());
-    } else {
-        ra_.Emit<EcmaDefinefuncdyn>(node, name, static_cast<int64_t>(formalParamCnt), LexEnv());
+        ra_.Emit<Definemethod>(node, 0, name, static_cast<int64_t>(formalParamCnt));
+    } else  {
+        ra_.Emit<Definefunc>(node, 0, name, static_cast<int64_t>(formalParamCnt));
     }
 
     strings_.insert(name);
@@ -1119,22 +1279,26 @@ void PandaGen::DefineFunction(const ir::AstNode *node, const ir::ScriptFunction
 
 void PandaGen::TypeOf(const ir::AstNode *node)
 {
-    sa_.Emit<EcmaTypeofdyn>(node);
+    // modify ic later
+    sa_.Emit<Typeof>(node, 0);
 }
 
 void PandaGen::CallSpread(const ir::AstNode *node, VReg func, VReg thisReg, VReg args)
 {
-    ra_.Emit<EcmaCallspreaddyn>(node, func, thisReg, args);
+    // modify ic later
+    LoadAccumulator(node, func); // callee is load to acc
+    ra_.Emit<Apply>(node, 0, thisReg, args);
 }
 
-void PandaGen::NewObjSpread(const ir::AstNode *node, VReg obj, VReg target)
+void PandaGen::NewObjSpread(const ir::AstNode *node, VReg obj)
 {
-    ra_.Emit<EcmaNewobjspreaddyn>(node, obj, target);
+    // modify ic later
+    ra_.Emit<Newobjapply>(node, 0, obj);
 }
 
 void PandaGen::GetUnmappedArgs(const ir::AstNode *node)
 {
-    sa_.Emit<EcmaGetunmappedargs>(node);
+    sa_.Emit<Getunmappedargs>(node);
 }
 
 void PandaGen::Negate(const ir::AstNode *node)
@@ -1151,35 +1315,39 @@ void PandaGen::Negate(const ir::AstNode *node)
 
 void PandaGen::ToNumber(const ir::AstNode *node, VReg arg)
 {
-    ra_.Emit<EcmaTonumber>(node, arg);
+    // modify ic later
+    LoadAccumulator(node, arg);
+    sa_.Emit<Tonumber>(node, 0);
 }
 
 void PandaGen::ToNumeric(const ir::AstNode *node, VReg arg)
 {
-    ra_.Emit<EcmaTonumeric>(node, arg);
+    // modify ic later
+    LoadAccumulator(node, arg);
+    sa_.Emit<Tonumeric>(node, 0);
 }
 
 void PandaGen::CreateGeneratorObj(const ir::AstNode *node, VReg funcObj)
 {
-    ra_.Emit<EcmaCreategeneratorobj>(node, funcObj);
+    ra_.Emit<Creategeneratorobj>(node, funcObj);
 }
 
 void PandaGen::CreateAsyncGeneratorObj(const ir::AstNode *node, VReg funcObj)
 {
     /*
      *  TODO: async generator
-     *  ra_.Emit<EcmaCreateasyncgeneratorobj>(node, funcObj);
+     *  ra_.Emit<Createasyncgeneratorobj>(node, funcObj);
      */
 }
 
 void PandaGen::CreateIterResultObject(const ir::AstNode *node, VReg value, VReg done)
 {
-    ra_.Emit<EcmaCreateiterresultobj>(node, value, done);
+    ra_.Emit<Createiterresultobj>(node, value, done);
 }
 
-void PandaGen::SuspendGenerator(const ir::AstNode *node, VReg genObj, VReg iterResult)
+void PandaGen::SuspendGenerator(const ir::AstNode *node, VReg genObj)
 {
-    ra_.Emit<EcmaSuspendgenerator>(node, genObj, iterResult);
+    ra_.Emit<Suspendgenerator>(node, genObj); // iterResult is in acc
 }
 
 void PandaGen::SuspendAsyncGenerator(const ir::AstNode *node, VReg asyncGenObj)
@@ -1208,39 +1376,41 @@ void PandaGen::GeneratorComplete(const ir::AstNode *node, VReg genObj)
 
 void PandaGen::ResumeGenerator(const ir::AstNode *node, VReg genObj)
 {
-    ra_.Emit<EcmaResumegenerator>(node, genObj);
+    LoadAccumulator(node, genObj);
+    sa_.Emit<Resumegenerator>(node);
 }
 
 void PandaGen::GetResumeMode(const ir::AstNode *node, VReg genObj)
 {
-    ra_.Emit<EcmaGetresumemode>(node, genObj);
+    LoadAccumulator(node, genObj);
+    sa_.Emit<Getresumemode>(node);
 }
 
 void PandaGen::AsyncFunctionEnter(const ir::AstNode *node)
 {
-    sa_.Emit<EcmaAsyncfunctionenter>(node);
+    sa_.Emit<Asyncfunctionenter>(node);
 }
 
-void PandaGen::AsyncFunctionAwait(const ir::AstNode *node, VReg asyncFuncObj, VReg retVal)
+void PandaGen::AsyncFunctionAwait(const ir::AstNode *node, VReg asyncFuncObj)
 {
-    ra_.Emit<EcmaAsyncfunctionawaituncaught>(node, asyncFuncObj, retVal);
+    ra_.Emit<Asyncfunctionawaituncaught>(node, asyncFuncObj); // receivedValue is in acc
 }
 
-void PandaGen::AsyncFunctionResolve(const ir::AstNode *node, VReg asyncFuncObj, VReg value, VReg canSuspend)
+void PandaGen::AsyncFunctionResolve(const ir::AstNode *node, VReg asyncFuncObj)
 {
-    ra_.Emit<EcmaAsyncfunctionresolve>(node, asyncFuncObj, canSuspend, value);
+    ra_.Emit<Asyncfunctionresolve>(node, asyncFuncObj); // use retVal in acc
 }
 
-void PandaGen::AsyncFunctionReject(const ir::AstNode *node, VReg asyncFuncObj, VReg value, VReg canSuspend)
+void PandaGen::AsyncFunctionReject(const ir::AstNode *node, VReg asyncFuncObj)
 {
-    ra_.Emit<EcmaAsyncfunctionreject>(node, asyncFuncObj, canSuspend, value);
+    ra_.Emit<Asyncfunctionreject>(node, asyncFuncObj); // exception is in acc
 }
 
 void PandaGen::AsyncGeneratorResolve(const ir::AstNode *node, VReg asyncGenObj)
 {
     /*
      *  TODO: async generator resolve
-     *  ra_.Emit<EcmaAsyncgeneratorresolve>(node, asyncGenObj);
+     *  ra_.Emit<Asyncgeneratorresolve>(node, asyncGenObj);
      */
 }
 
@@ -1254,68 +1424,69 @@ void PandaGen::AsyncGeneratorReject(const ir::AstNode *node, VReg asyncGenObj)
 
 void PandaGen::GetTemplateObject(const ir::AstNode *node, VReg value)
 {
-    ra_.Emit<EcmaGettemplateobject>(node, value);
+    // modify ic later
+    LoadAccumulator(node, value);
+    sa_.Emit<Gettemplateobject>(node, 0);
 }
 
 void PandaGen::CopyRestArgs(const ir::AstNode *node, uint32_t index)
 {
-    sa_.Emit<EcmaCopyrestargs>(node, index);
+    index <= util::Helpers::MAX_INT8 ? sa_.Emit<Copyrestargs>(node, index) : sa_.Emit<WideCopyrestargs>(node, index);
 }
 
 void PandaGen::GetPropIterator(const ir::AstNode *node)
 {
-    sa_.Emit<EcmaGetpropiterator>(node);
+    sa_.Emit<Getpropiterator>(node);
 }
 
 void PandaGen::GetNextPropName(const ir::AstNode *node, VReg iter)
 {
-    ra_.Emit<EcmaGetnextpropname>(node, iter);
+    ra_.Emit<Getnextpropname>(node, iter);
 }
 
 void PandaGen::CreateEmptyObject(const ir::AstNode *node)
 {
-    sa_.Emit<EcmaCreateemptyobject>(node);
+    sa_.Emit<Createemptyobject>(node);
 }
 
 void PandaGen::CreateObjectWithBuffer(const ir::AstNode *node, uint32_t idx)
 {
     ASSERT(util::Helpers::IsInteger<uint32_t>(idx));
-    sa_.Emit<EcmaCreateobjectwithbuffer>(node, idx);
-}
-
-void PandaGen::CreateObjectHavingMethod(const ir::AstNode *node, uint32_t idx)
-{
-    ASSERT(util::Helpers::IsInteger<uint32_t>(idx));
-    LoadAccumulator(node, LexEnv());
-    sa_.Emit<EcmaCreateobjecthavingmethod>(node, idx);
+    std::string idxStr = std::string(context_->RecordName()) + std::to_string(idx);
+    util::UString litId(idxStr, allocator_);
+    sa_.Emit<Createobjectwithbuffer>(node, 0, litId.View());
 }
 
 void PandaGen::SetObjectWithProto(const ir::AstNode *node, VReg proto, VReg obj)
 {
-    ra_.Emit<EcmaSetobjectwithproto>(node, proto, obj);
+    LoadAccumulator(node, obj);
+    ra_.Emit<Setobjectwithproto>(node, 0, proto);
 }
 
-void PandaGen::CopyDataProperties(const ir::AstNode *node, VReg dst, VReg src)
+void PandaGen::CopyDataProperties(const ir::AstNode *node, VReg dst)
 {
-    ra_.Emit<EcmaCopydataproperties>(node, dst, src);
+    ra_.Emit<Copydataproperties>(node, dst); // use acc as srcObj
 }
 
 void PandaGen::DefineGetterSetterByValue(const ir::AstNode *node, VReg obj, VReg name, VReg getter, VReg setter,
                                          bool setName)
 {
     LoadConst(node, setName ? Constant::JS_TRUE : Constant::JS_FALSE);
-    ra_.Emit<EcmaDefinegettersetterbyvalue>(node, obj, name, getter, setter);
+    ra_.Emit<Definegettersetterbyvalue>(node, obj, name, getter, setter);
 }
 
 void PandaGen::CreateEmptyArray(const ir::AstNode *node)
 {
-    sa_.Emit<EcmaCreateemptyarray>(node);
+    // modify ic later
+    sa_.Emit<Createemptyarray>(node, 0);
 }
 
 void PandaGen::CreateArrayWithBuffer(const ir::AstNode *node, uint32_t idx)
 {
     ASSERT(util::Helpers::IsInteger<uint32_t>(idx));
-    sa_.Emit<EcmaCreatearraywithbuffer>(node, idx);
+    std::string idxStr = std::string(context_->RecordName()) + std::to_string(idx);
+    util::UString litId(idxStr, allocator_);
+    sa_.Emit<Createarraywithbuffer>(node, 0, litId.View());
 }
 
 void PandaGen::CreateArray(const ir::AstNode *node, const ArenaVector<ir::Expression *> &elements, VReg obj)
@@ -1416,22 +1587,23 @@ void PandaGen::CreateArray(const ir::AstNode *node, const ArenaVector<ir::Expres
 
 void PandaGen::StoreArraySpread(const ir::AstNode *node, VReg array, VReg index)
 {
-    ra_.Emit<EcmaStarrayspread>(node, array, index);
+    ra_.Emit<Starrayspread>(node, array, index);
 }
 
 void PandaGen::ThrowIfNotObject(const ir::AstNode *node, VReg obj)
 {
-    ra_.Emit<EcmaThrowifnotobject>(node, obj);
+    ra_.Emit<ThrowIfnotobject>(node, obj);
 }
 
 void PandaGen::ThrowThrowNotExist(const ir::AstNode *node)
 {
-    sa_.Emit<EcmaThrowthrownotexists>(node);
+    sa_.Emit<ThrowNotexists>(node);
 }
 
 void PandaGen::GetIterator(const ir::AstNode *node)
 {
-    sa_.Emit<EcmaGetiterator>(node);
+    // modify ic later
+    sa_.Emit<Getiterator>(node, 0);
 }
 
 void PandaGen::GetAsyncIterator(const ir::AstNode *node)
@@ -1451,71 +1623,93 @@ void PandaGen::CreateObjectWithExcludedKeys(const ir::AstNode *node, VReg obj, V
     }
 
     size_t argRegCnt = (argCount == 0 ? argCount : argCount - 1);
-    rra_.Emit<EcmaCreateobjectwithexcludedkeys>(node, argStart, argCount, static_cast<int64_t>(argRegCnt), obj,
-                                                argStart);
+
+    if (argRegCnt <= util::Helpers::MAX_INT8) {
+        rra_.Emit<Createobjectwithexcludedkeys>(node, argStart, argCount, static_cast<int64_t>(argRegCnt),
+                                                    obj, argStart);
+        return;
+    }
+
+    rra_.Emit<WideCreateobjectwithexcludedkeys>(node, argStart, argCount, static_cast<int64_t>(argRegCnt),
+                                                obj, argStart);
 }
 
 void PandaGen::ThrowObjectNonCoercible(const ir::AstNode *node)
 {
-    sa_.Emit<EcmaThrowpatternnoncoercible>(node);
+    sa_.Emit<ThrowPatternnoncoercible>(node);
 }
 
 void PandaGen::CloseIterator(const ir::AstNode *node, VReg iter)
 {
-    ra_.Emit<EcmaCloseiterator>(node, iter);
+    // modify ic later
+    ra_.Emit<Closeiterator>(node, 0, iter);
 }
 
-void PandaGen::DefineClassWithBuffer(const ir::AstNode *node, const util::StringView &ctorId, int32_t litIdx,
-                                     VReg lexenv, VReg base)
+void PandaGen::DefineClassWithBuffer(const ir::AstNode *node, const util::StringView &ctorId, int32_t litIdx, VReg base)
 {
+    // modify ic later
     auto formalParamCnt = node->AsClassDefinition()->Ctor()->Function()->FormalParamsLength();
-    ra_.Emit<EcmaDefineclasswithbuffer>(node, ctorId, litIdx, static_cast<int64_t>(formalParamCnt), lexenv, base);
+    std::string idxStr = std::string(context_->RecordName()) + std::to_string(litIdx);
+    util::UString litId(idxStr, allocator_);
+    ra_.Emit<Defineclasswithbuffer>(node, 0, ctorId, litId.View(), static_cast<int64_t>(formalParamCnt), base);
     strings_.insert(ctorId);
 }
 
-void PandaGen::LoadModuleVariable(const ir::AstNode *node, const util::StringView &name, bool isLocalExport)
+void PandaGen::LoadLocalModuleVariable(const ir::AstNode *node, const binder::ModuleVariable *variable)
 {
-    ra_.Emit<EcmaLdmodulevar>(node, name, isLocalExport ? static_cast<uint8_t>(1) : static_cast<uint8_t>(0));
-    strings_.insert(name);
+    auto index = variable->Index();
+    index <= util::Helpers::MAX_INT8 ? sa_.Emit<Ldlocalmodulevar>(node, index) :
+                                       sa_.Emit<WideLdlocalmodulevar>(node, index);
 }
 
-void PandaGen::StoreModuleVariable(const ir::AstNode *node, const util::StringView &name)
+void PandaGen::LoadExternalModuleVariable(const ir::AstNode *node, const binder::ModuleVariable *variable)
 {
-    sa_.Emit<EcmaStmodulevar>(node, name);
-    strings_.insert(name);
+    auto index = variable->Index();
+    index <= util::Helpers::MAX_INT8 ? sa_.Emit<Ldexternalmodulevar>(node, index) :
+                                       sa_.Emit<WideLdexternalmodulevar>(node, index);
 }
 
-void PandaGen::GetModuleNamespace(const ir::AstNode *node, const util::StringView &name)
+void PandaGen::StoreModuleVariable(const ir::AstNode *node, const binder::ModuleVariable *variable)
 {
-    sa_.Emit<EcmaGetmodulenamespace>(node, name);
-    strings_.insert(name);
+    auto index = variable->Index();
+    index <= util::Helpers::MAX_INT8 ? sa_.Emit<Stmodulevar>(node, index) :
+                                       sa_.Emit<WideStmodulevar>(node, index);
 }
 
-void PandaGen::DynamicImportCall(const ir::AstNode *node, VReg moduleSpecifier)
+void PandaGen::GetModuleNamespace(const ir::AstNode *node, uint32_t index)
 {
-    ra_.Emit<EcmaDynamicimport>(node, moduleSpecifier);
+    index <= util::Helpers::MAX_INT8 ? sa_.Emit<Getmodulenamespace>(node, index) :
+                                       sa_.Emit<WideGetmodulenamespace>(node, index);
+}
+
+void PandaGen::DynamicImportCall(const ir::AstNode *node)
+{
+    ra_.Emit<Dynamicimport>(node);
 }
 
 void PandaGen::StSuperByName(const ir::AstNode *node, VReg obj, const util::StringView &key)
 {
-    ra_.Emit<EcmaStsuperbyname>(node, key, obj);
+    ra_.Emit<Stsuperbyname>(node, 0, key, obj);
     strings_.insert(key);
 }
 
 void PandaGen::LdSuperByName(const ir::AstNode *node, VReg obj, const util::StringView &key)
 {
-    ra_.Emit<EcmaLdsuperbyname>(node, key, obj);
+    // modify ic later
+    LoadAccumulator(node, obj); // object is load to acc
+    sa_.Emit<Ldsuperbyname>(node, 0, key);
     strings_.insert(key);
 }
 
 void PandaGen::StSuperByValue(const ir::AstNode *node, VReg obj, VReg prop)
 {
-    ra_.Emit<EcmaStsuperbyvalue>(node, obj, prop);
+    ra_.Emit<Stsuperbyvalue>(node, 0, obj, prop);
 }
 
-void PandaGen::LdSuperByValue(const ir::AstNode *node, VReg obj, VReg prop)
+void PandaGen::LdSuperByValue(const ir::AstNode *node, VReg obj)
 {
-    ra_.Emit<EcmaLdsuperbyvalue>(node, obj, prop);
+    // modify ic later
+    ra_.Emit<Ldsuperbyvalue>(node, 0, obj); // prop is in acc
 }
 
 void PandaGen::StoreSuperProperty(const ir::AstNode *node, VReg obj, const Operand &prop)
@@ -1550,63 +1744,80 @@ void PandaGen::LoadSuperProperty(const ir::AstNode *node, VReg obj, const Operan
     }
 
     if (std::holds_alternative<VReg>(prop)) {
-        LdSuperByValue(node, obj, std::get<VReg>(prop));
+        LoadAccumulator(node, std::get<VReg>(prop));
+        LdSuperByValue(node, obj);
         return;
     }
 
     ASSERT(std::holds_alternative<int64_t>(prop));
-    RegScope rs(this);
 
     LoadAccumulatorInt(node, static_cast<size_t>(std::get<int64_t>(prop)));
-    VReg property = AllocReg();
-    StoreAccumulator(node, property);
-    LdSuperByValue(node, obj, property);
+    LdSuperByValue(node, obj);
 }
 
 void PandaGen::LoadLexicalVar(const ir::AstNode *node, uint32_t level, uint32_t slot)
 {
-    sa_.Emit<EcmaLdlexvardyn>(node, level, slot);
+    if ((level > util::Helpers::MAX_INT8) || (slot > util::Helpers::MAX_INT8)) {
+        sa_.Emit<WideLdlexvar>(node, level, slot);
+        return;
+    }
+
+    sa_.Emit<Ldlexvar>(node, level, slot);
 }
 
 void PandaGen::LoadLexicalVar(const ir::AstNode *node, uint32_t level, uint32_t slot, const util::StringView &name)
 {
     if (context_->HotfixHelper() && context_->HotfixHelper()->IsPatchVar(slot)) {
         uint32_t patchSlot = context_->HotfixHelper()->GetPatchLexicalIdx(std::string(name));
-        sa_.Emit<EcmaLdpatchvar>(node, patchSlot);
+        sa_.Emit<WideLdpatchvar>(node, patchSlot);
+        return;
+    }
+
+    if ((level > util::Helpers::MAX_INT8) || (slot > util::Helpers::MAX_INT8)) {
+        sa_.Emit<WideLdlexvar>(node, level, slot);
         return;
     }
-    sa_.Emit<EcmaLdlexvardyn>(node, level, slot);
+
+    sa_.Emit<Ldlexvar>(node, level, slot);
 }
 
 void PandaGen::StoreLexicalVar(const ir::AstNode *node, uint32_t level, uint32_t slot)
 {
-    RegScope rs(this);
-    VReg value = AllocReg();
-    StoreAccumulator(node, value);
-    ra_.Emit<EcmaStlexvardyn>(node, level, slot, value);
+    if ((level > util::Helpers::MAX_INT8) || (slot > util::Helpers::MAX_INT8)) {
+        ra_.Emit<WideStlexvar>(node, level, slot);
+        return;
+    }
+
+    ra_.Emit<Stlexvar>(node, level, slot);
 }
 
 void PandaGen::StoreLexicalVar(const ir::AstNode *node, uint32_t level, uint32_t slot, VReg value)
 {
-    ra_.Emit<EcmaStlexvardyn>(node, level, slot, value);
+    LoadAccumulator(node, value);
+    if ((level > util::Helpers::MAX_INT8) || (slot > util::Helpers::MAX_INT8)) {
+        ra_.Emit<WideStlexvar>(node, level, slot);
+        return;
+    }
+
+    ra_.Emit<Stlexvar>(node, level, slot);
 }
 
 void PandaGen::StoreLexicalVar(const ir::AstNode *node, uint32_t level, uint32_t slot, const util::StringView &name)
 {
     if (context_->HotfixHelper() && context_->HotfixHelper()->IsPatchVar(slot)) {
         uint32_t patchSlot = context_->HotfixHelper()->GetPatchLexicalIdx(std::string(name));
-        sa_.Emit<EcmaStpatchvar>(node, patchSlot);
+        sa_.Emit<WideStpatchvar>(node, patchSlot);
         return;
     }
     RegScope rs(this);
     VReg value = AllocReg();
     StoreAccumulator(node, value);
-    ra_.Emit<EcmaStlexvardyn>(node, level, slot, value);
+    StoreLexicalVar(node, level, slot, value);
 }
 
 void PandaGen::ThrowIfSuperNotCorrectCall(const ir::AstNode *node, int64_t num)
 {
-    sa_.Emit<EcmaThrowifsupernotcorrectcall>(node, num);
+    sa_.Emit<ThrowIfsupernotcorrectcall>(node, num);
 }
 
 void PandaGen::ThrowUndefinedIfHole(const ir::AstNode *node, const util::StringView &name)
@@ -1617,7 +1828,7 @@ void PandaGen::ThrowUndefinedIfHole(const ir::AstNode *node, const util::StringV
     LoadAccumulatorString(node, name);
     VReg nameReg = AllocReg();
     StoreAccumulator(node, nameReg);
-    ra_.Emit<EcmaThrowundefinedifhole>(node, holeReg, nameReg);
+    ra_.Emit<ThrowUndefinedifhole>(node, holeReg, nameReg);
     LoadAccumulator(node, holeReg);
     strings_.insert(name);
 }
@@ -1628,13 +1839,13 @@ void PandaGen::ThrowConstAssignment(const ir::AstNode *node, const util::StringV
     LoadAccumulatorString(node, name);
     VReg nameReg = AllocReg();
     StoreAccumulator(node, nameReg);
-    ra_.Emit<EcmaThrowconstassignment>(node, nameReg);
+    ra_.Emit<ThrowConstassignment>(node, nameReg);
     strings_.insert(name);
 }
 
 void PandaGen::PopLexEnv(const ir::AstNode *node)
 {
-    sa_.Emit<EcmaPoplexenvdyn>(node);
+    sa_.Emit<Poplexenv>(node);
 }
 
 void PandaGen::CopyLexEnv(const ir::AstNode *node)
@@ -1658,17 +1869,15 @@ void PandaGen::NewLexicalEnv(const ir::AstNode *node, uint32_t num, binder::Vari
 
 void PandaGen::NewLexEnv(const ir::AstNode *node, uint32_t num)
 {
-    sa_.Emit<EcmaNewlexenvdyn>(node, num);
+    num <= util::Helpers::MAX_INT8 ? sa_.Emit<Newlexenv>(node, num) : sa_.Emit<WideNewlexenv>(node, num);
 }
 
 void PandaGen::NewLexEnvWithScopeInfo(const ir::AstNode *node, uint32_t num, int32_t scopeInfoIdx)
 {
-    sa_.Emit<EcmaNewlexenvwithnamedyn>(node, num, scopeInfoIdx);
-}
-
-void PandaGen::LdLexEnv(const ir::AstNode *node)
-{
-    sa_.Emit<EcmaLdlexenvdyn>(node);
+    std::string idxStr = std::string(context_->RecordName()) + std::to_string(scopeInfoIdx);
+    util::UString litId(idxStr, allocator_);
+    num <= util::Helpers::MAX_INT8 ? sa_.Emit<Newlexenvwithname>(node, num, litId.View()) :
+                                     sa_.Emit<WideNewlexenvwithname>(node, num, litId.View());
 }
 
 uint32_t PandaGen::TryDepth() const
@@ -1786,21 +1995,17 @@ VReg PandaGen::LoadPropertyKey(const ir::Expression *prop, bool isComputed)
     return propReg;
 }
 
-void PandaGen::StLetToGlobalRecord(const ir::AstNode *node, const util::StringView &name)
+void PandaGen::StLetOrClassToGlobalRecord(const ir::AstNode *node, const util::StringView &name)
 {
-    sa_.Emit<EcmaStlettoglobalrecord>(node, name);
+    // modify ic later
+    sa_.Emit<Sttoglobalrecord>(node, 0, name);
     strings_.insert(name);
 }
 
 void PandaGen::StConstToGlobalRecord(const ir::AstNode *node, const util::StringView &name)
 {
-    sa_.Emit<EcmaStconsttoglobalrecord>(node, name);
-    strings_.insert(name);
-}
-
-void PandaGen::StClassToGlobalRecord(const ir::AstNode *node, const util::StringView &name)
-{
-    sa_.Emit<EcmaStclasstoglobalrecord>(node, name);
+    // modify ic later
+    sa_.Emit<Stconsttoglobalrecord>(node, 0, name);
     strings_.insert(name);
 }
 
diff --git a/es2panda/compiler/core/pandagen.h b/es2panda/compiler/core/pandagen.h
index 64fe2d6132bd853e72f05f55102588d262f135a5..bd67715b6ac220e6fa33b3d54de22c3fd8f89665 100644
--- a/es2panda/compiler/core/pandagen.h
+++ b/es2panda/compiler/core/pandagen.h
@@ -28,6 +28,7 @@
 
 namespace panda::es2panda::binder {
 class FunctionScope;
+class ModuleVaribale;
 class ScopeFindResult;
 class Scope;
 }  // namespace panda::es2panda::binder
@@ -60,6 +61,16 @@ enum class Constant {
     JS_GLOBAL,
 };
 
+enum class FunctionKind : uint8_t {
+    NONE = 0x0, // represent method for now
+    FUNCTION = 0x1,
+    NC_FUNCTION = 0x2,
+    GENERATOR_FUNCTION = 0x3,
+    ASYNC_FUNCTION = 0x4,
+    ASYNC_GENERATOR_FUNCTION = 0x5,
+    ASYNC_NCFUNCTION = 0x6
+};
+
 class DebugInfo {
 public:
     explicit DebugInfo(ArenaAllocator *allocator) : variableDebugInfo(allocator->Adapter()) {};
@@ -186,6 +197,13 @@ public:
         rra_.SetSourceLocationFlag(flag);
     }
 
+    FunctionKind GetFunctionKind() const
+    {
+        return funcKind_;
+    }
+
+    void SetFunctionKind();
+
     bool IsDebug() const;
     bool isDebuggerEvaluateExpressionMode() const;
     std::string SourceFile() const;
@@ -198,8 +216,6 @@ public:
 
     Label *AllocLabel();
 
-    VReg LexEnv() const;
-
     bool FunctionHasFinalizer() const;
     void FunctionInit(CatchTable* catchTable);
     void FunctionEnter();
@@ -209,7 +225,7 @@ public:
     int32_t AddLiteralBuffer(LiteralBuffer *buf);
     int32_t AddLexicalVarNamesForDebugInfo(ArenaMap<uint32_t, std::pair<util::StringView, int>> &lexicalMap);
 
-    void InitializeLexEnv(const ir::AstNode *node, VReg lexEnv);
+    void InitializeLexEnv(const ir::AstNode *node);
     void CopyFunctionArguments(const ir::AstNode *node);
     void GetFunctionObject(const ir::AstNode *node);
     void GetNewTarget(const ir::AstNode *node);
@@ -218,9 +234,8 @@ public:
     void LoadVar(const ir::Identifier *node, const binder::ScopeFindResult &result);
     void StoreVar(const ir::AstNode *node, const binder::ScopeFindResult &result, bool isDeclaration);
 
-    void StLetToGlobalRecord(const ir::AstNode *node, const util::StringView &name);
+    void StLetOrClassToGlobalRecord(const ir::AstNode *node, const util::StringView &name);
     void StConstToGlobalRecord(const ir::AstNode *node, const util::StringView &name);
-    void StClassToGlobalRecord(const ir::AstNode *node, const util::StringView &name);
 
     void StoreAccumulator(const ir::AstNode *node, VReg vreg);
     void LoadAccFromArgs(const ir::AstNode *node);
@@ -234,7 +249,6 @@ public:
     void LoadAccumulator(const ir::AstNode *node, VReg reg);
     void LoadGlobalVar(const ir::AstNode *node, const util::StringView &name);
     void StoreGlobalVar(const ir::AstNode *node, const util::StringView &name);
-    void StoreGlobalLet(const ir::AstNode *node, const util::StringView &name);
 
     void TryLoadGlobalByValue(const ir::AstNode *node, VReg key);
     void TryStoreGlobalByValue(const ir::AstNode *node, VReg key);
@@ -265,6 +279,15 @@ public:
     void Condition(const ir::AstNode *node, lexer::TokenType op, VReg lhs, class Label *ifFalse);
     void Unary(const ir::AstNode *node, lexer::TokenType op, VReg operand);
     void Binary(const ir::AstNode *node, lexer::TokenType op, VReg lhs);
+    void Equal(const ir::AstNode *node, VReg lhs);
+    void NotEqual(const ir::AstNode *node, VReg lhs);
+    void StrictEqual(const ir::AstNode *node, VReg lhs);
+    void StrictNotEqual(const ir::AstNode *node, VReg lhs);
+    void LessThan(const ir::AstNode *node, VReg lhs);
+    void LessEqual(const ir::AstNode *node, VReg lhs);
+    void GreaterThan(const ir::AstNode *node, VReg lhs);
+    void GreaterEqual(const ir::AstNode *node, VReg lhs);
+    void IsTrue(const ir::AstNode *node);
 
     void BranchIfUndefined(const ir::AstNode *node, class Label *target);
     void BranchIfStrictNotUndefined(const ir::AstNode *node, class Label *target);
@@ -290,12 +313,11 @@ public:
     void SuperCall(const ir::AstNode *node, VReg startReg, size_t argCount);
     void SuperCallSpread(const ir::AstNode *node, VReg vs);
 
-    void LoadHomeObject(const ir::AstNode *node);
     void NewObject(const ir::AstNode *node, VReg startReg, size_t argCount);
     void DefineFunction(const ir::AstNode *node, const ir::ScriptFunction *realNode, const util::StringView &name);
 
     void TypeOf(const ir::AstNode *node);
-    void NewObjSpread(const ir::AstNode *node, VReg obj, VReg target);
+    void NewObjSpread(const ir::AstNode *node, VReg obj);
     void GetUnmappedArgs(const ir::AstNode *node);
 
     void Negate(const ir::AstNode *node);
@@ -307,15 +329,15 @@ public:
     void GetResumeMode(const ir::AstNode *node, VReg genObj);
 
     void AsyncFunctionEnter(const ir::AstNode *node);
-    void AsyncFunctionAwait(const ir::AstNode *node, VReg asyncFuncObj, VReg retVal);
-    void AsyncFunctionResolve(const ir::AstNode *node, VReg asyncFuncObj, VReg value, VReg canSuspend);
-    void AsyncFunctionReject(const ir::AstNode *node, VReg asyncFuncObj, VReg value, VReg canSuspend);
+    void AsyncFunctionAwait(const ir::AstNode *node, VReg asyncFuncObj);
+    void AsyncFunctionResolve(const ir::AstNode *node, VReg asyncFuncObj);
+    void AsyncFunctionReject(const ir::AstNode *node, VReg asyncFuncObj);
 
     void GeneratorYield(const ir::AstNode *node, VReg genObj);
     void GeneratorComplete(const ir::AstNode *node, VReg genObj);
     void CreateAsyncGeneratorObj(const ir::AstNode *node, VReg funcObj);
     void CreateIterResultObject(const ir::AstNode *node, VReg value, VReg done);
-    void SuspendGenerator(const ir::AstNode *node, VReg genObj, VReg iterResult);
+    void SuspendGenerator(const ir::AstNode *node, VReg genObj);
     void SuspendAsyncGenerator(const ir::AstNode *node, VReg asyncGenObj);
 
     void AsyncGeneratorResolve(const ir::AstNode *node, VReg asyncGenObj);
@@ -328,9 +350,8 @@ public:
     void GetNextPropName(const ir::AstNode *node, VReg iter);
     void CreateEmptyObject(const ir::AstNode *node);
     void CreateObjectWithBuffer(const ir::AstNode *node, uint32_t idx);
-    void CreateObjectHavingMethod(const ir::AstNode *node, uint32_t idx);
     void SetObjectWithProto(const ir::AstNode *node, VReg proto, VReg obj);
-    void CopyDataProperties(const ir::AstNode *node, VReg dst, VReg src);
+    void CopyDataProperties(const ir::AstNode *node, VReg dst);
     void DefineGetterSetterByValue(const ir::AstNode *node, VReg obj, VReg name, VReg getter, VReg setter,
                                    bool setName);
     void CreateEmptyArray(const ir::AstNode *node);
@@ -346,22 +367,21 @@ public:
     void CreateObjectWithExcludedKeys(const ir::AstNode *node, VReg obj, VReg argStart, size_t argCount);
     void ThrowObjectNonCoercible(const ir::AstNode *node);
     void CloseIterator(const ir::AstNode *node, VReg iter);
-    void DefineClassWithBuffer(const ir::AstNode *node, const util::StringView &ctorId, int32_t litIdx, VReg lexenv,
-                               VReg base);
+    void DefineClassWithBuffer(const ir::AstNode *node, const util::StringView &ctorId, int32_t litIdx, VReg base);
 
-    void LoadModuleVariable(const ir::AstNode *node, const util::StringView &name, bool isLocalExport);
-    void StoreModuleVariable(const ir::AstNode *node, const util::StringView &name);
-    void GetModuleNamespace(const ir::AstNode *node, const util::StringView &name);
-    void DynamicImportCall(const ir::AstNode *node, VReg moduleSpecifier);
+    void LoadLocalModuleVariable(const ir::AstNode *node, const binder::ModuleVariable *variable);
+    void LoadExternalModuleVariable(const ir::AstNode *node, const binder::ModuleVariable *variable);
+    void StoreModuleVariable(const ir::AstNode *node, const binder::ModuleVariable *variable);
+    void GetModuleNamespace(const ir::AstNode *node, uint32_t index);
+    void DynamicImportCall(const ir::AstNode *node);
 
     void StSuperByName(const ir::AstNode *node, VReg obj, const util::StringView &key);
     void LdSuperByName(const ir::AstNode *node, VReg obj, const util::StringView &key);
     void StSuperByValue(const ir::AstNode *node, VReg obj, VReg prop);
-    void LdSuperByValue(const ir::AstNode *node, VReg obj, VReg prop);
+    void LdSuperByValue(const ir::AstNode *node, VReg obj);
     void StoreSuperProperty(const ir::AstNode *node, VReg obj, const Operand &prop);
     void LoadSuperProperty(const ir::AstNode *node, VReg obj, const Operand &prop);
 
-    void LdLexEnv(const ir::AstNode *node);
     void PopLexEnv(const ir::AstNode *node);
     void CopyLexEnv(const ir::AstNode *node);
     void NewLexicalEnv(const ir::AstNode *node, uint32_t num, binder::VariableScope *scope);
@@ -382,7 +402,7 @@ public:
     void SortCatchTables();
 
     void LoadObjByIndex(const ir::AstNode *node, VReg obj, int64_t index);
-    void LoadObjByValue(const ir::AstNode *node, VReg obj, VReg prop);
+    void LoadObjByValue(const ir::AstNode *node, VReg obj);
 
     void StoreObjByName(const ir::AstNode *node, VReg obj, const util::StringView &prop);
     void StoreObjByIndex(const ir::AstNode *node, VReg obj, int64_t index);
@@ -416,6 +436,16 @@ public:
         throw Error(ErrorType::GENERIC, "Unimplemented code path");
     }
 
+    ICSize GetCurrentSlot() const
+    {
+        return currentSlot_;
+    }
+
+    void IncreaseCurrentSlot(ICSlot inc)
+    {
+        currentSlot_ += inc;
+    }
+
 private:
     ArenaAllocator *allocator_;
     CompilerContext *context_;
@@ -434,6 +464,7 @@ private:
     SimpleAllocator sa_;
     RegAllocator ra_;
     RangeRegAllocator rra_;
+    ICSize currentSlot_ {0};
 
     uint32_t usedRegs_ {0};
     uint32_t totalRegs_ {0};
@@ -447,6 +478,7 @@ private:
     friend class LoopEnvScope;
     friend class DynamicContext;
     size_t labelId_ {0};
+    FunctionKind funcKind_ {FunctionKind::NONE};
 };
 }  // namespace panda::es2panda::compiler
 
diff --git a/es2panda/compiler/core/regAllocator.cpp b/es2panda/compiler/core/regAllocator.cpp
index 1601722e66e1080bf507fe7015f1136c82073397..01f3f81ebad6c75d7f63b52f373fbd1aa3cae358 100644
--- a/es2panda/compiler/core/regAllocator.cpp
+++ b/es2panda/compiler/core/regAllocator.cpp
@@ -21,7 +21,7 @@
 
 namespace panda::es2panda::compiler {
 
-// RegAllocatorBase
+// AllocatorBase
 
 void AllocatorBase::PushBack(IRNode *ins)
 {
@@ -33,12 +33,10 @@ ArenaAllocator *AllocatorBase::Allocator() const
     return pg_->Allocator();
 }
 
-// SimpleAllocator
-
-Label *SimpleAllocator::AllocLabel(std::string &&id)
+void AllocatorBase::UpdateIcSlot(IRNode *node)
 {
-    const auto *lastInsNode = pg_->Insns().empty() ? FIRST_NODE_OF_FUNCTION : pg_->Insns().back()->Node();
-    return Alloc<Label>(lastInsNode, std::move(id));
+    auto inc = node->SetIcSlot(pg_->GetCurrentSlot());
+    pg_->IncreaseCurrentSlot(inc);
 }
 
 // FrontAllocator
@@ -53,6 +51,13 @@ FrontAllocator::~FrontAllocator()
     pg_->Insns().splice(pg_->Insns().end(), std::move(insn_));
 }
 
+// SimpleAllocator
+Label *SimpleAllocator::AllocLabel(std::string &&id)
+{
+    const auto *lastInsNode = pg_->Insns().empty() ? FIRST_NODE_OF_FUNCTION : pg_->Insns().back()->Node();
+    return Alloc<Label>(lastInsNode, std::move(id));
+}
+
 // RegAllocatorBase
 
 VReg RegAllocatorBase::Spill(IRNode *ins, VReg reg)
@@ -61,8 +66,8 @@ VReg RegAllocatorBase::Spill(IRNode *ins, VReg reg)
     VReg origin = spillIndex_++;
     spillMap_.emplace(origin, reg);
 
-    Add<MovDyn>(ins->Node(), spillReg, origin);
-    Add<MovDyn>(ins->Node(), origin, reg);
+    Add<Mov>(ins->Node(), spillReg, origin);
+    Add<Mov>(ins->Node(), origin, reg);
 
     return origin;
 }
@@ -74,8 +79,8 @@ void RegAllocatorBase::Restore(IRNode *ins)
     VReg origin = regEnd_ + spillIndex_;
     VReg actualReg = spillMap_[spillReg];
 
-    Add<MovDyn>(ins->Node(), actualReg, spillReg);
-    Add<MovDyn>(ins->Node(), spillReg, origin);
+    Add<Mov>(ins->Node(), actualReg, spillReg);
+    Add<Mov>(ins->Node(), spillReg, origin);
 }
 
 // RegAllocator
diff --git a/es2panda/compiler/core/regAllocator.h b/es2panda/compiler/core/regAllocator.h
index 16f6ca4a01075ec82e2b01f5c8b4aa3bb5b811cc..9edf1d8cf3133ee05ea607e910ec03988dc53e1b 100644
--- a/es2panda/compiler/core/regAllocator.h
+++ b/es2panda/compiler/core/regAllocator.h
@@ -56,10 +56,14 @@ protected:
     T *Alloc(const ir::AstNode *node, Args &&... args)
     {
         ir::AstNode *invalidNode = nullptr;
-        return Allocator()->New<T>((GetSourceLocationFlag() == lexer::SourceLocationFlag::INVALID_SOURCE_LOCATION) ?
-                                   invalidNode : node, std::forward<Args>(args)...);
+        bool isInvalid = GetSourceLocationFlag() == lexer::SourceLocationFlag::INVALID_SOURCE_LOCATION;
+        auto *ret = Allocator()->New<T>(isInvalid ? invalidNode : node, std::forward<Args>(args)...);
+        UpdateIcSlot(ret);
+        return ret;
     }
 
+    void UpdateIcSlot(IRNode *node);
+
     template <typename T, typename... Args>
     void Add(const ir::AstNode *node, Args &&... args)
     {
diff --git a/es2panda/compiler/core/regScope.cpp b/es2panda/compiler/core/regScope.cpp
index 196a0190158857d2145355fbb1570169161bb12f..24bbcd709eeb5059e9d4d87b56368e950351b84b 100644
--- a/es2panda/compiler/core/regScope.cpp
+++ b/es2panda/compiler/core/regScope.cpp
@@ -94,7 +94,7 @@ FunctionRegScope::FunctionRegScope(PandaGen *pg) : RegScope(pg), envScope_(pg->A
         }
     }
 
-    envScope_->Initialize(pg_, pg->AllocReg());
+    envScope_->Initialize(pg_);
 
     for (const auto &[_, var] : funcScope->Bindings()) {
         (void)_;
diff --git a/es2panda/compiler/function/asyncFunctionBuilder.cpp b/es2panda/compiler/function/asyncFunctionBuilder.cpp
index b89db47075446fa6b0b84cd52f54886f21982407..da2a187e2212b6f57cd2b79b8f504b850124a3ab 100644
--- a/es2panda/compiler/function/asyncFunctionBuilder.cpp
+++ b/es2panda/compiler/function/asyncFunctionBuilder.cpp
@@ -23,13 +23,7 @@ namespace panda::es2panda::compiler {
 
 void AsyncFunctionBuilder::DirectReturn(const ir::AstNode *node) const
 {
-    RegScope rs(pg_);
-    VReg retVal = pg_->AllocReg();
-    VReg canSuspend = pg_->AllocReg();
-
-    pg_->StoreAccumulator(node, retVal);
-    pg_->StoreConst(node, canSuspend, Constant::JS_TRUE);
-    pg_->AsyncFunctionResolve(node, funcObj_, retVal, canSuspend);
+    pg_->AsyncFunctionResolve(node, funcObj_); // retVal is in acc
     pg_->EmitReturn(node);
 }
 
@@ -54,10 +48,8 @@ void AsyncFunctionBuilder::CleanUp(const ir::ScriptFunction *node) const
     pg_->SetLabel(node, labelSet.TryEnd());
     pg_->SetLabel(node, labelSet.CatchBegin());
     VReg exception = pg_->AllocReg();
-    VReg canSuspend = pg_->AllocReg();
     pg_->StoreAccumulator(node, exception);
-    pg_->StoreConst(node, canSuspend, Constant::JS_TRUE);
-    pg_->AsyncFunctionReject(node, funcObj_, exception, canSuspend);
+    pg_->AsyncFunctionReject(node, funcObj_);
     pg_->EmitReturn(node);
     pg_->SetLabel(node, labelSet.CatchEnd());
 }
diff --git a/es2panda/compiler/function/asyncGeneratorFunctionBuilder.cpp b/es2panda/compiler/function/asyncGeneratorFunctionBuilder.cpp
index a74eea46df994ebcf77a2c6e04bdbe664a8b0831..ada09cd4de30b87f08b839f86ef131e6d5661bc3 100644
--- a/es2panda/compiler/function/asyncGeneratorFunctionBuilder.cpp
+++ b/es2panda/compiler/function/asyncGeneratorFunctionBuilder.cpp
@@ -72,7 +72,7 @@ void AsyncGeneratorFunctionBuilder::Yield(const ir::AstNode *node)
     pg_->Condition(node, lexer::TokenType::PUNCTUATOR_EQUAL, completionType, notReturnCompletion);
     // 27.6.3.8.8.b. Let awaited be Await(resumptionValue.[[Value]]).
     pg_->LoadAccumulator(node, completionValue);
-    pg_->AsyncFunctionAwait(node, funcObj_, completionValue);
+    pg_->AsyncFunctionAwait(node, funcObj_);
     SuspendResumeExecution(node, completionType, completionValue);
 
     // 27.6.3.8.8.c. If awaited.[[Type]] is throw, return Completion(awaited).
diff --git a/es2panda/compiler/function/functionBuilder.cpp b/es2panda/compiler/function/functionBuilder.cpp
index e6ba14286f873ae08a073e3f46234dc6f16d21c7..6f63bd057f65e7c02134ae920ebc7c7862a2cd11 100644
--- a/es2panda/compiler/function/functionBuilder.cpp
+++ b/es2panda/compiler/function/functionBuilder.cpp
@@ -72,10 +72,7 @@ void FunctionBuilder::SuspendResumeExecution(const ir::AstNode *node, VReg compl
     ASSERT(BuilderKind() == BuilderType::ASYNC || BuilderKind() == BuilderType::ASYNC_GENERATOR ||
            BuilderKind() == BuilderType::GENERATOR);
 
-    RegScope rs(pg_);
-    VReg iterResult = pg_->AllocReg();
-    pg_->StoreAccumulator(node, iterResult);
-    pg_->SuspendGenerator(node, funcObj_, iterResult);
+    pg_->SuspendGenerator(node, funcObj_); // iterResult is in acc
     resumeGenerator(node, completionType, completionValue);
 }
 
@@ -110,10 +107,8 @@ void FunctionBuilder::Await(const ir::AstNode *node)
     RegScope rs(pg_);
     VReg completionType = pg_->AllocReg();
     VReg completionValue = pg_->AllocReg();
-    VReg retVal = pg_->AllocReg();
 
-    pg_->StoreAccumulator(node, retVal);
-    pg_->AsyncFunctionAwait(node, funcObj_, retVal);
+    pg_->AsyncFunctionAwait(node, funcObj_);
     SuspendResumeExecution(node, completionType, completionValue);
 
     HandleCompletion(node, completionType, completionValue);
@@ -276,7 +271,8 @@ void FunctionBuilder::YieldStar(const ir::AstNode *node)
         pg_->Condition(node, lexer::TokenType::PUNCTUATOR_EQUAL, receivedType, loopStart);
 
         // b. Let awaited be Await(resumptionValue.[[Value]]).
-        pg_->AsyncFunctionAwait(node, funcObj_, receivedValue);
+        pg_->LoadAccumulator(node, receivedValue);
+        pg_->AsyncFunctionAwait(node, funcObj_);
         SuspendResumeExecution(node, receivedType, receivedValue);
 
         // c. If awaited.[[Type]] is throw, return Completion(awaited).
diff --git a/es2panda/compiler/templates/isa.h.erb b/es2panda/compiler/templates/isa.h.erb
index 49a5d5869c1eb651fd6c158ffd6743636b347afe..aa2051cde05eccca378c7edcfaba51cab962604d 100644
--- a/es2panda/compiler/templates/isa.h.erb
+++ b/es2panda/compiler/templates/isa.h.erb
@@ -64,6 +64,11 @@ public:
         ins->label = id_;
     }
 
+    ICSlot SetIcSlot(ICSize currentSlot) override
+    {
+        return 0;
+    }
+
 private:
     std::string id_;
 };
@@ -130,6 +135,7 @@ private:
 %     ops = Array.new
 %     ctor_args = Array.new
 %     op_map = Hash.new { |h, k| h[k] = [] }
+%     id_count = 0
 %     operands.map do |operand|
 %     operand_parts = operand.split(':')
 %       case operand_parts.size
@@ -146,7 +152,9 @@ private:
 %       name_tmp = name_tmp = name.to_s.gsub(/[0-9]/, '').to_sym;
 %
 %       if is_Id(name_tmp)
-%           name = "stringId"
+%           name = "stringId_"
+%           name.concat(id_count.to_s)
+%           id_count = id_count + 1
 %       end
 %
 %       ops.push(name)
@@ -195,28 +203,74 @@ public:
         return <%= reg_cnt %>;
     }
 
-    void Transform(pandasm::Ins* ins) const override {
-      ins->opcode = pandasm::Opcode::<%= node_kind %>;
+    void Transform(pandasm::Ins* ins) const override
+    {
+        ins->opcode = pandasm::Opcode::<%= node_kind %>;
 % if op_map['reg'].length != 0
-      ins->regs.reserve(<%= op_map['reg'].length %>);
+        ins->regs.reserve(<%= op_map['reg'].length %>);
 % end
 % if op_map['imm'].length != 0
-      ins->imms.reserve(<%= op_map['imm'].length %>);
+        ins->imms.reserve(<%= op_map['imm'].length %>);
 % end
 % if op_map['str'].length + op_map['lbl'].length != 0
-      ins->ids.reserve(<%= op_map['str'].length + op_map['lbl'].length %>);
+        ins->ids.reserve(<%= op_map['str'].length + op_map['lbl'].length %>);
 % end
 % for reg in op_map['reg']
-      ins->regs.emplace_back(<%= reg %>);
+        ins->regs.emplace_back(<%= reg %>);
 % end
 % for imm in op_map['imm']
-      ins->imms.emplace_back(<%= imm %>);
+        ins->imms.emplace_back(<%= imm %>);
 % end
 % for str in op_map['str']
-      ins->ids.emplace_back(<%= str %>.Mutf8());
+        ins->ids.emplace_back(<%= str %>.Mutf8());
 % end
 % for lbl in op_map['lbl']
-      ins->ids.emplace_back(<%= lbl %>->Id());
+        ins->ids.emplace_back(<%= lbl %>->Id());
+% end
+    }
+
+    ICSlot SetIcSlot(ICSize slot) override
+    {
+% is_jit_ic = insn.properties.include?("jit_ic_slot")
+% is_ic = (!is_jit_ic) && insn.properties.include?("ic_slot")
+% if (!is_jit_ic && !is_ic)
+        return 0;
+% else
+%   ret = insn.properties.include?("one_slot") ? 1 : 2;
+        constexpr static ICSlot invalid = 0xFF;
+%   if (is_ic)
+        if (slot <= 0xFF) {
+            if ((slot + <%= ret %>) > 0xFF) {
+                <%= op_map['imm'][0] %> = 0x100;
+                return <%= ret %> + (0x100 - slot);
+            }
+
+            <%= op_map['imm'][0] %> = slot;
+            return <%= ret %>;
+        }
+
+        if (slot > 0xFF && slot <= 0xFFFF) {
+            <%= op_map['imm'][0] %> = slot;
+            return <%= ret %>;
+        }
+
+        <%= op_map['imm'][0] %> = invalid;
+        return 0;
+%   end
+%   if (is_jit_ic && !is_ic)
+        if (slot < 0xFF) {
+            if ((slot + <%= ret %>) > 0xFF) {
+                <%= op_map['imm'][0] %> = invalid;
+                return 0;
+            }
+
+            <%= op_map['imm'][0] %> = slot;
+            return <%= ret %>;
+        }
+
+        <%= op_map['imm'][0] %> = invalid;
+        return 0;
+%   end
 % end
     }
 
diff --git a/es2panda/ir/base/classDefinition.cpp b/es2panda/ir/base/classDefinition.cpp
index bda274c4ac7d7ef7e522149daeb9038222f44b18..2b850b83e580b2c1c047043a430369700e3980ea 100644
--- a/es2panda/ir/base/classDefinition.cpp
+++ b/es2panda/ir/base/classDefinition.cpp
@@ -287,7 +287,6 @@ void ClassDefinition::Compile(compiler::PandaGen *pg) const
 
     compiler::RegScope rs(pg);
     compiler::VReg classReg = pg->AllocReg();
-    compiler::VReg lexenv = pg->LexEnv();
 
     compiler::LocalRegScope lrs(pg, scope_);
 
@@ -296,7 +295,7 @@ void ClassDefinition::Compile(compiler::PandaGen *pg) const
     util::BitSet compiled(body_.size());
 
     int32_t bufIdx = CreateClassStaticProperties(pg, compiled);
-    pg->DefineClassWithBuffer(this, ctorId, bufIdx, lexenv, baseReg);
+    pg->DefineClassWithBuffer(this, ctorId, bufIdx, baseReg);
 
     pg->StoreAccumulator(this, classReg);
     InitializeClassName(pg);
diff --git a/es2panda/ir/expressions/callExpression.cpp b/es2panda/ir/expressions/callExpression.cpp
index dc09961b5d94c2e2c318738f2fccf1956035c239..9e63b9f2a4cf12723008ac1cafe36831135059ed 100644
--- a/es2panda/ir/expressions/callExpression.cpp
+++ b/es2panda/ir/expressions/callExpression.cpp
@@ -94,7 +94,6 @@ void CallExpression::Compile(compiler::PandaGen *pg) const
                 pg->StoreAccumulator(it, arg);
             }
 
-            pg->GetFunctionObject(this);
             pg->SuperCall(this, argStart, arguments_.size());
         }
 
diff --git a/es2panda/ir/expressions/importExpression.cpp b/es2panda/ir/expressions/importExpression.cpp
index b8f112960f106419113821f4bb45068b5c8b24b0..ec88d45b4d142d9405a32e9419bc9ee7cd353e37 100644
--- a/es2panda/ir/expressions/importExpression.cpp
+++ b/es2panda/ir/expressions/importExpression.cpp
@@ -32,11 +32,8 @@ void ImportExpression::Dump(ir::AstDumper *dumper) const
 
 void ImportExpression::Compile(compiler::PandaGen *pg) const
 {
-    compiler::RegScope rs(pg);
-    compiler::VReg moduleSpecifier = pg->AllocReg();
     source_->Compile(pg);
-    pg->StoreAccumulator(this, moduleSpecifier);
-    pg->DynamicImportCall(this, moduleSpecifier);
+    pg->DynamicImportCall(this);
 }
 
 checker::Type *ImportExpression::Check([[maybe_unused]] checker::Checker *checker) const
diff --git a/es2panda/ir/expressions/literals/regExpLiteral.cpp b/es2panda/ir/expressions/literals/regExpLiteral.cpp
index 6fb9c4e3c9406e5597cd8e6d4c32e0f01f96e8c7..f63d01aff1d8c65e0edff55422a278ecdfdb00d5 100644
--- a/es2panda/ir/expressions/literals/regExpLiteral.cpp
+++ b/es2panda/ir/expressions/literals/regExpLiteral.cpp
@@ -35,13 +35,11 @@ void RegExpLiteral::Compile(compiler::PandaGen *pg) const
     compiler::RegScope rs(pg);
     /* [ ctor, newTarget, regexpPattern(, regexpFlags) ] */
     compiler::VReg ctor = pg->AllocReg();
-    compiler::VReg newTarget = pg->AllocReg();
     compiler::VReg pattern = pg->AllocReg();
-    size_t argCount = 3;
+    size_t argCount = 2;
 
     pg->TryLoadGlobalByName(this, "RegExp");
     pg->StoreAccumulator(this, ctor);
-    pg->StoreAccumulator(this, newTarget);
 
     pg->LoadAccumulatorString(this, pattern_);
     pg->StoreAccumulator(this, pattern);
diff --git a/es2panda/ir/expressions/newExpression.cpp b/es2panda/ir/expressions/newExpression.cpp
index 937eee65c5eafbdf5ff577efe5bcc40d3c072cfb..b7b2f253521fd134043ed36a69c931c153e2a3e2 100644
--- a/es2panda/ir/expressions/newExpression.cpp
+++ b/es2panda/ir/expressions/newExpression.cpp
@@ -47,14 +47,10 @@ void NewExpression::Compile(compiler::PandaGen *pg) const
 {
     compiler::RegScope rs(pg);
     compiler::VReg ctor = pg->AllocReg();
-    compiler::VReg newTarget = pg->AllocReg();
 
     callee_->Compile(pg);
     pg->StoreAccumulator(this, ctor);
 
-    // new.Target will be the same as ctor
-    pg->StoreAccumulator(this, newTarget);
-
     if (!util::Helpers::ContainSpreadElement(arguments_)) {
         for (const auto *it : arguments_) {
             compiler::VReg arg = pg->AllocReg();
@@ -62,12 +58,12 @@ void NewExpression::Compile(compiler::PandaGen *pg) const
             pg->StoreAccumulator(this, arg);
         }
 
-        pg->NewObject(this, ctor, arguments_.size() + 2);
+        pg->NewObject(this, ctor, arguments_.size() + 1);
     } else {
         compiler::VReg argsObj = pg->AllocReg();
 
         pg->CreateArray(this, arguments_, argsObj);
-        pg->NewObjSpread(this, ctor, newTarget);
+        pg->NewObjSpread(this, ctor);
     }
 }
 
diff --git a/es2panda/ir/expressions/objectExpression.cpp b/es2panda/ir/expressions/objectExpression.cpp
index b68364ffc11f98a685a7691688c1ab0e3d34b3c6..b4c365666a332c7ff37f3b8384244b9edf853d80 100644
--- a/es2panda/ir/expressions/objectExpression.cpp
+++ b/es2panda/ir/expressions/objectExpression.cpp
@@ -234,12 +234,7 @@ void ObjectExpression::EmitCreateObjectWithBuffer(compiler::PandaGen *pg, compil
     }
 
     uint32_t bufIdx = pg->AddLiteralBuffer(buf);
-
-    if (hasMethod) {
-        pg->CreateObjectHavingMethod(this, bufIdx);
-    } else {
-        pg->CreateObjectWithBuffer(this, bufIdx);
-    }
+    pg->CreateObjectWithBuffer(this, bufIdx);
 }
 
 static const Literal *CreateLiteral(compiler::PandaGen *pg, const ir::Property *prop, util::BitSet *compiled,
@@ -355,13 +350,11 @@ void ObjectExpression::CompileRemainingProperties(compiler::PandaGen *pg, const
         compiler::RegScope rs(pg);
 
         if (properties_[i]->IsSpreadElement()) {
-            compiler::VReg srcObj = pg->AllocReg();
             const ir::SpreadElement *spread = properties_[i]->AsSpreadElement();
 
             spread->Argument()->Compile(pg);
-            pg->StoreAccumulator(spread, srcObj);
-
-            pg->CopyDataProperties(spread, objReg, srcObj);
+            // srcObj is now stored in acc
+            pg->CopyDataProperties(spread, objReg);
             continue;
         }
 
diff --git a/es2panda/ir/irnode.h b/es2panda/ir/irnode.h
index 1382b7c4edec8e83da5d6cfad465bba23316fa43..227e62bc9e3954a5c7c75b7737443fee9ff0ee4f 100644
--- a/es2panda/ir/irnode.h
+++ b/es2panda/ir/irnode.h
@@ -98,6 +98,10 @@ using Operand = std::variant<compiler::VReg, double, int64_t, util::StringView,
 
 #define FIRST_NODE_OF_FUNCTION (reinterpret_cast<ir::AstNode *>(0x1))
 
+using ICSlot = uint16_t;
+
+using ICSize = uint32_t;
+
 class IRNode {
 public:
     explicit IRNode(const ir::AstNode *node) : node_(node) {};
@@ -117,6 +121,7 @@ public:
     virtual size_t Registers([[maybe_unused]] std::array<VReg *, MAX_REG_OPERAND> *regs) = 0;
     virtual size_t Registers([[maybe_unused]] std::array<const VReg *, MAX_REG_OPERAND> *regs) const = 0;
     virtual void Transform(panda::pandasm::Ins *ins) const = 0;
+    virtual ICSlot SetIcSlot(ICSize currentSlot) = 0;
 
 private:
     const ir::AstNode *node_;
diff --git a/es2panda/ir/module/exportDefaultDeclaration.cpp b/es2panda/ir/module/exportDefaultDeclaration.cpp
index 1a7f06a213d9e545741c4b87685c233ba2879cbd..7612a55558b08951827749d3fa5456905ba7884a 100644
--- a/es2panda/ir/module/exportDefaultDeclaration.cpp
+++ b/es2panda/ir/module/exportDefaultDeclaration.cpp
@@ -37,7 +37,10 @@ void ExportDefaultDeclaration::Compile(compiler::PandaGen *pg) const
     if (decl_->IsExpression()) {
         // export default [AssignmentExpression]
         // e.g. export default 42 (42 be exported as [default])
-        pg->StoreModuleVariable(this, parser::SourceTextModuleRecord::DEFAULT_LOCAL_NAME);
+        ASSERT(pg->Scope()->IsModuleScope());
+        auto *var = pg->Scope()->FindLocal(parser::SourceTextModuleRecord::DEFAULT_LOCAL_NAME);
+        ASSERT(var->IsModuleVariable());
+        pg->StoreModuleVariable(this, var->AsModuleVariable());
     }
 }
 
diff --git a/es2panda/parser/module/sourceTextModuleRecord.cpp b/es2panda/parser/module/sourceTextModuleRecord.cpp
index d6af0a9399a9cc2952104eb6c6119b2cc56b5935..cdcac267ea0d37ac8c27f34d411093d3b94329cb 100644
--- a/es2panda/parser/module/sourceTextModuleRecord.cpp
+++ b/es2panda/parser/module/sourceTextModuleRecord.cpp
@@ -13,6 +13,8 @@
  * limitations under the License.
  */
 
+#include <binder/scope.h>
+
 #include "sourceTextModuleRecord.h"
 
 namespace panda::es2panda::parser {
@@ -160,4 +162,21 @@ namespace panda::es2panda::parser {
         exportEntry->moduleRequestIdx_ = importEntry->moduleRequestIdx_;
         exportEntry->localName_ = util::StringView("");
     }
+
+    void SourceTextModuleRecord::AssignIndexToModuleVariable(binder::ModuleScope *moduleScope)
+    {
+        uint32_t index = 0;
+        for (auto it = localExportEntries_.begin(); it != localExportEntries_.end();
+             it = localExportEntries_.upper_bound(it->first))
+        {
+            moduleScope->AssignIndexToModuleVariable(it->first, index);
+            index++;
+        }
+
+        index = 0;
+        for (const auto &elem : regularImportEntries_) {
+            moduleScope->AssignIndexToModuleVariable(elem.first, index);
+            index++;
+        }
+    }
 } // namespace panda::es2panda::parser
diff --git a/es2panda/parser/module/sourceTextModuleRecord.h b/es2panda/parser/module/sourceTextModuleRecord.h
index 8b15e3d975cff23650744f54a746fc9154c10562..674db844a6e396421e0da671fed2a42db6e8ac78 100644
--- a/es2panda/parser/module/sourceTextModuleRecord.h
+++ b/es2panda/parser/module/sourceTextModuleRecord.h
@@ -18,6 +18,10 @@
 
 #include <util/ustring.h>
 
+namespace panda::es2panda::binder {
+class ModuleScope;
+}
+
 namespace panda::es2panda::parser {
 class SourceTextModuleRecord {
 public:
@@ -80,6 +84,8 @@ public:
     bool CheckImplicitIndirectExport(ExportEntry *exportEntry);
     void CheckImplicitIndirectExport(ImportEntry *importEntry);
 
+    void AssignIndexToModuleVariable(binder::ModuleScope *moduleScope);
+
     using ModuleRequestList = ArenaVector<util::StringView>;
     using ModuleRequestMap = ArenaMap<const util::StringView, uint32_t>;
     using LocalExportEntryMap = ArenaMultiMap<const util::StringView, ExportEntry *>;
diff --git a/es2panda/util/helpers.h b/es2panda/util/helpers.h
index d9021aa9e2b383837240f561c9aff15c2866af41..e4d2d4ccab30aa2aa8f4adb3e28d1fe5415c45ac 100644
--- a/es2panda/util/helpers.h
+++ b/es2panda/util/helpers.h
@@ -81,6 +81,8 @@ public:
 
     static const uint32_t INVALID_INDEX = 4294967295L;
     static const uint32_t MAX_INT32 = 2147483647;
+    static const uint32_t MAX_INT16 = std::numeric_limits<int16_t>::max();
+    static const uint32_t MAX_INT8 = std::numeric_limits<int8_t>::max();
 };
 
 template <typename T>
diff --git a/es2panda/util/hotfix.cpp b/es2panda/util/hotfix.cpp
index 1241548e805a5f0386e81600f97bd45ea047fcda..9cea4ae5cf4bddd9b4087f4c2451d19a1b3f67aa 100644
--- a/es2panda/util/hotfix.cpp
+++ b/es2panda/util/hotfix.cpp
@@ -117,11 +117,11 @@ std::vector<std::pair<std::string, size_t>> Hotfix::GenerateFunctionAndClassHash
 
     for (const auto &ins : func->ins) {
         ss << (ins.set_label ? "" : "\t") << ins.ToString("", true, func->GetTotalRegs()) << " ";
-        if (ins.opcode == panda::pandasm::Opcode::ECMA_CREATEARRAYWITHBUFFER ||
-            ins.opcode == panda::pandasm::Opcode::ECMA_CREATEOBJECTWITHBUFFER) {
+        if (ins.opcode == panda::pandasm::Opcode::CREATEARRAYWITHBUFFER ||
+            ins.opcode == panda::pandasm::Opcode::CREATEOBJECTWITHBUFFER) {
             int64_t bufferIdx = std::get<int64_t>(ins.imms[0]);
             ss << ExpandLiteral(bufferIdx, literalBuffers) << " ";
-        } else if (ins.opcode == panda::pandasm::Opcode::ECMA_DEFINECLASSWITHBUFFER) {
+        } else if (ins.opcode == panda::pandasm::Opcode::DEFINECLASSWITHBUFFER) {
             int64_t bufferIdx = std::get<int64_t>(ins.imms[0]);
             std::string literalStr = ExpandLiteral(bufferIdx, literalBuffers);
             auto classHash = std::hash<std::string>{}(literalStr);
@@ -252,11 +252,9 @@ uint32_t Hotfix::GetPatchLexicalIdx(const std::string &variableName)
 
 bool IsFunctionOrClassDefineIns(panda::pandasm::Ins &ins)
 {
-    if (ins.opcode == panda::pandasm::Opcode::ECMA_DEFINEGENERATORFUNC ||
-        ins.opcode == panda::pandasm::Opcode::ECMA_DEFINEMETHOD ||
-        ins.opcode == panda::pandasm::Opcode::ECMA_DEFINEFUNCDYN ||
-        ins.opcode == panda::pandasm::Opcode::ECMA_DEFINEASYNCFUNC ||
-        ins.opcode == panda::pandasm::Opcode::ECMA_DEFINECLASSWITHBUFFER) {
+    if (ins.opcode == panda::pandasm::Opcode::DEFINEMETHOD ||
+        ins.opcode == panda::pandasm::Opcode::DEFINEFUNC ||
+        ins.opcode == panda::pandasm::Opcode::DEFINECLASSWITHBUFFER) {
         return true;
     }
     return false;
@@ -301,7 +299,7 @@ void Hotfix::HandleModifiedClasses(panda::pandasm::Program *prog)
 void Hotfix::AddHeadAndTailInsForPatchFuncMain0(std::vector<panda::pandasm::Ins> &ins)
 {
     panda::pandasm::Ins returnUndefine;
-    returnUndefine.opcode = pandasm::Opcode::ECMA_RETURNUNDEFINED;
+    returnUndefine.opcode = pandasm::Opcode::RETURNUNDEFINED;
 
     if (ins.size() == 0) {
         ins.push_back(returnUndefine);
@@ -309,13 +307,13 @@ void Hotfix::AddHeadAndTailInsForPatchFuncMain0(std::vector<panda::pandasm::Ins>
     }
 
     panda::pandasm::Ins newLexenv;
-    newLexenv.opcode = pandasm::Opcode::ECMA_NEWLEXENVDYN;
+    newLexenv.opcode = pandasm::Opcode::NEWLEXENV;
     newLexenv.imms.reserve(1);
     auto newFuncNum = long(ins.size() / 2);  // each new function has 2 ins: define and store
     newLexenv.imms.emplace_back(newFuncNum);
 
     panda::pandasm::Ins stLexenv;
-    stLexenv.opcode = pandasm::Opcode::STA_DYN;
+    stLexenv.opcode = pandasm::Opcode::STA;
     stLexenv.regs.reserve(1);
     stLexenv.regs.emplace_back(PATCH_ENV_VREG);
 
diff --git a/ts2panda/src/base/bcGenUtil.ts b/ts2panda/src/base/bcGenUtil.ts
index 4cfe01289676b6cdd12141a02eaa2422e6994bae..6123d2cd8f3e0550c1597db241ceaf7ede3e75fa 100644
--- a/ts2panda/src/base/bcGenUtil.ts
+++ b/ts2panda/src/base/bcGenUtil.ts
@@ -14,104 +14,119 @@
  */
 
 import {
-    EcmaCallarg0dyn,
-    EcmaCallarg1dyn,
-    EcmaCallargs2dyn,
-    EcmaCallargs3dyn,
-    EcmaCallirangedyn,
-    EcmaCallithisrangedyn,
-    EcmaCloseiterator,
-    EcmaCopydataproperties,
-    EcmaCreatearraywithbuffer,
-    EcmaCreateemptyarray,
-    EcmaCreateemptyobject,
-    EcmaCreateobjecthavingmethod,
-    EcmaCreateobjectwithbuffer,
-    EcmaCreateobjectwithexcludedkeys,
-    EcmaCreateregexpwithliteral,
-    EcmaDebugger,
-    EcmaDefineasyncfunc,
-    EcmaDefineclasswithbuffer,
-    EcmaDefinefuncdyn,
-    EcmaDefinegeneratorfunc,
-    EcmaDefineasyncgeneratorfunc,
-    EcmaDefinegettersetterbyvalue,
-    EcmaDefinemethod,
-    EcmaDefinencfuncdyn,
-    EcmaDelobjprop,
-    EcmaDynamicimport,
-    EcmaGetiterator,
-    EcmaGetiteratornext,
-    EcmaGetnextpropname,
-    EcmaGetpropiterator,
-    EcmaGetmodulenamespace,
-    EcmaIsfalse,
-    EcmaIstrue,
-    EcmaLdglobalvar,
-    EcmaLdhomeobject,
-    EcmaLdlexenvdyn,
-    EcmaLdlexvardyn,
-    EcmaLdmodulevar,
-    EcmaLdobjbyindex,
-    EcmaLdobjbyname,
-    EcmaLdobjbyvalue,
-    EcmaLdsuperbyname,
-    EcmaLdsuperbyvalue,
-    EcmaNewlexenvdyn,
-    EcmaNewlexenvwithnamedyn,
-    EcmaNewobjdynrange,
-    EcmaPoplexenvdyn,
-    EcmaReturnundefined,
-    EcmaSetobjectwithproto,
-    EcmaStarrayspread,
-    EcmaStclasstoglobalrecord,
-    EcmaStconsttoglobalrecord,
-    EcmaStglobalvar,
-    EcmaStlettoglobalrecord,
-    EcmaStlexvardyn,
-    EcmaStmodulevar,
-    EcmaStobjbyindex,
-    EcmaStobjbyname,
-    EcmaStobjbyvalue,
-    EcmaStownbyindex,
-    EcmaStownbyname,
-    EcmaStownbynamewithnameset,
-    EcmaStownbyvalue,
-    EcmaStownbyvaluewithnameset,
-    EcmaStsuperbyname,
-    EcmaStsuperbyvalue,
-    EcmaSupercall,
-    EcmaSupercallspread,
-    EcmaThrowconstassignment,
-    EcmaThrowdeletesuperproperty,
-    EcmaThrowdyn,
-    EcmaThrowifnotobject,
-    EcmaThrowifsupernotcorrectcall,
-    EcmaThrowpatternnoncoercible,
-    EcmaThrowthrownotexists,
-    EcmaThrowundefinedifhole,
-    EcmaTryldglobalbyname,
-    EcmaTrystglobalbyname,
-    FldaiDyn,
+    Dynamicimport,
+    Callarg0,
+    Callarg1,
+    Callargs2,
+    Callargs3,
+    Callrange,
+    WideCallrange,
+    Callthis0,
+    Callthis1,
+    Callthis2,
+    Callthis3,
+    Callthisrange,
+    WideCallthisrange,
+    Closeiterator,
+    Copydataproperties,
+    Createarraywithbuffer,
+    Createemptyarray,
+    Createemptyobject,
+    Createobjectwithbuffer,
+    Createobjectwithexcludedkeys,
+    Createregexpwithliteral,
+    Debugger,
+    Defineclasswithbuffer,
+    Definefunc,
+    Definegettersetterbyvalue,
+    Definemethod,
+    Delobjprop,
+    Getiterator,
+    Getnextpropname,
+    Getpropiterator,
+    Getmodulenamespace,
+    Isfalse,
+    Istrue,
+    Ldglobalvar,
+    Ldlexvar,
+    Ldobjbyindex,
+    Ldobjbyname,
+    Ldobjbyvalue,
+    Ldsuperbyname,
+    Ldsuperbyvalue,
+    Newlexenv,
+    Newlexenvwithname,
+    Newobjrange,
+    Poplexenv,
+    Returnundefined,
+    Setobjectwithproto,
+    Starrayspread,
+    Stconsttoglobalrecord,
+    Stglobalvar,
+    Stlexvar,
+    Stmodulevar,
+    Stobjbyindex,
+    Stobjbyname,
+    Stobjbyvalue,
+    Stownbyindex,
+    Stownbyname,
+    Stownbynamewithnameset,
+    Stownbyvalue,
+    Stownbyvaluewithnameset,
+    Stsuperbyname,
+    Stsuperbyvalue,
+    Supercallthisrange,
+    Supercallspread,
+    ThrowConstassignment,
+    ThrowDeletesuperproperty,
+    Throw,
+    ThrowIfnotobject,
+    ThrowIfsupernotcorrectcall,
+    ThrowPatternnoncoercible,
+    ThrowNotexists,
+    ThrowUndefinedifhole,
+    Tryldglobalbyname,
+    Trystglobalbyname,
+    Fldai,
     Imm,
     IRNode,
     Jmp,
     Label,
-    LdaDyn,
-    LdaiDyn,
+    Lda,
+    Ldai,
     LdaStr,
-    MovDyn,
-    StaDyn,
-    EcmaLdbigint,
-    VReg
+    Mov,
+    Sta,
+    Ldbigint,
+    VReg,
+    WideNewlexenv,
+    WideNewlexenvwithname,
+    WideLdlexvar,
+    WideStlexvar,
+    WideLdobjbyindex,
+    WideStobjbyindex,
+    WideStownbyindex,
+    WideNewobjrange,
+    WideCreateobjectwithexcludedkeys,
+    WideSupercallthisrange,
+    WideSupercallarrowrange,
+    Supercallarrowrange,
+    WideGetmodulenamespace,
+    Ldlocalmodulevar,
+    WideLdlocalmodulevar,
+    Ldexternalmodulevar,
+    WideLdexternalmodulevar,
+    WideStmodulevar,
+    Sttoglobalrecord
 } from "../irnodes";
+import { MAX_INT16, MAX_INT8 } from "./util";
 
 export function loadAccumulatorInt(value: number): IRNode {
-    return new LdaiDyn(new Imm(value));
+    return new Ldai(new Imm(value));
 }
 
 export function loadAccumulatorFloat(value: number): IRNode {
-    return new FldaiDyn(new Imm(value));
+    return new Fldai(new Imm(value));
 }
 
 export function loadAccumulatorString(value: string): IRNode {
@@ -119,19 +134,19 @@ export function loadAccumulatorString(value: string): IRNode {
 }
 
 export function loadAccumulator(vreg: VReg): IRNode {
-    return new LdaDyn(vreg);
+    return new Lda(vreg);
 }
 
 export function storeAccumulator(vreg: VReg): IRNode {
-    return new StaDyn(vreg);
+    return new Sta(vreg);
 }
 
-export function deleteObjProperty(obj: VReg, prop: VReg): IRNode {
-    return new EcmaDelobjprop(obj, prop);
+export function deleteObjProperty(obj: VReg): IRNode {
+    return new Delobjprop(obj);
 }
 
 export function moveVreg(vd: VReg, vs: VReg): IRNode {
-    return new MovDyn(vd, vs);
+    return new Mov(vd, vs);
 }
 
 export function jumpTarget(target: Label): IRNode {
@@ -139,106 +154,116 @@ export function jumpTarget(target: Label): IRNode {
 }
 
 export function creatDebugger(): IRNode {
-    return new EcmaDebugger();
+    return new Debugger();
 }
 
 export function throwException(): IRNode {
-    return new EcmaThrowdyn();
+    return new Throw();
 }
 
 export function throwConstAssignment(name: VReg) {
-    return new EcmaThrowconstassignment(name);
+    return new ThrowConstassignment(name);
 }
 
 export function throwUndefinedIfHole(hole: VReg, name: VReg) {
-    return new EcmaThrowundefinedifhole(hole, name);
+    return new ThrowUndefinedifhole(hole, name);
 }
 
 export function throwThrowNotExists() {
-    return new EcmaThrowthrownotexists();
+    return new ThrowNotexists();
 }
 
 export function throwDeleteSuperProperty() {
-    return new EcmaThrowdeletesuperproperty();
+    return new ThrowDeletesuperproperty();
 }
 
 export function newLexicalEnv(numVars: number, scopeInfoIdx: number | undefined) {
     if (scopeInfoIdx == undefined) {
-        return new EcmaNewlexenvdyn(new Imm(numVars));
+        return numVars <= MAX_INT8 ? new Newlexenv(new Imm(numVars)) :
+                                     new WideNewlexenv(new Imm(numVars));
     }
-    return new EcmaNewlexenvwithnamedyn(new Imm(numVars), new Imm(scopeInfoIdx));
-}
-
-export function loadLexicalEnv() {
-    return new EcmaLdlexenvdyn();
+    let litId: string = scopeInfoIdx.toString()
+    return numVars <= MAX_INT8 ? new Newlexenvwithname(new Imm(numVars), litId) :
+                                 new WideNewlexenvwithname(new Imm(numVars), litId);
 }
 
 export function popLexicalEnv() {
-    return new EcmaPoplexenvdyn();
+    return new Poplexenv();
 }
 
 export function loadLexicalVar(level: number, slot: number) {
-    return new EcmaLdlexvardyn(new Imm(level), new Imm(slot));
+    if ((level > MAX_INT8) || (slot > MAX_INT8)) {
+        return new WideLdlexvar(new Imm(level), new Imm(slot));
+    }
+    return new Ldlexvar(new Imm(level), new Imm(slot));
 }
 
-export function storeLexicalVar(level: number, slot: number, value: VReg) {
-    return new EcmaStlexvardyn(new Imm(level), new Imm(slot), value);
+export function storeLexicalVar(level: number, slot: number) {
+    if ((level > MAX_INT8) || (slot > MAX_INT8)) {
+        return new WideStlexvar(new Imm(level), new Imm(slot));
+    }
+    return new Stlexvar(new Imm(level), new Imm(slot));
 }
 
 export function tryLoadGlobalByName(key: string) {
-    return new EcmaTryldglobalbyname(key);
+    return new Tryldglobalbyname(new Imm(0), key);
 }
 
 export function tryStoreGlobalByName(key: string) {
-    return new EcmaTrystglobalbyname(key);
+    return new Trystglobalbyname(new Imm(0), key);
 }
 
 export function loadGlobalVar(name: string) {
-    return new EcmaLdglobalvar(name);
+    return new Ldglobalvar(new Imm(0), name);
 }
 
 export function storeGlobalVar(name: string) {
-    return new EcmaStglobalvar(name);
+    return new Stglobalvar(new Imm(0), name);
 }
 
-export function loadObjByName(obj: VReg, key: string) {
-    return new EcmaLdobjbyname(key, obj);
+export function loadObjByName(key: string) {
+    return new Ldobjbyname(new Imm(0), key);
 }
 
 export function storeObjByName(obj: VReg, key: string) {
-    return new EcmaStobjbyname(key, obj);
+    return new Stobjbyname(new Imm(0), key, obj);
 }
 
-export function loadObjByIndex(obj: VReg, index: number) {
-    return new EcmaLdobjbyindex(obj, new Imm(index));
+export function loadObjByIndex(index: number) {
+    return index <= MAX_INT16 ? new Ldobjbyindex(new Imm(0), new Imm(index)) :
+                                new WideLdobjbyindex(new Imm(index));
 }
 
 export function storeObjByIndex(obj: VReg, index: number) {
-    return new EcmaStobjbyindex(obj, new Imm(index));
+    return index <= MAX_INT16 ? new Stobjbyindex(new Imm(0), obj, new Imm(index)) :
+                                new WideStobjbyindex(obj, new Imm(index));
 }
 
-export function loadObjByValue(obj: VReg, prop: VReg): IRNode {
-    return new EcmaLdobjbyvalue(obj, prop);
+export function loadObjByValue(obj: VReg): IRNode {
+    return new Ldobjbyvalue(new Imm(0), obj);
 }
 
 export function storeObjByValue(obj: VReg, prop: VReg): IRNode {
-    return new EcmaStobjbyvalue(obj, prop);
+    return new Stobjbyvalue(new Imm(0), obj, prop);
 }
 
 export function storeOwnByName(obj: VReg, key: string, nameSetting: boolean): IRNode {
-    return nameSetting ? new EcmaStownbynamewithnameset(key, obj) : new EcmaStownbyname(key, obj);
+    return nameSetting ? new Stownbynamewithnameset(new Imm(0), key, obj) :
+                         new Stownbyname(new Imm(0), key, obj);
 }
 
 export function storeOwnByIndex(obj: VReg, index: number) {
-    return new EcmaStownbyindex(obj, new Imm(index));
+    return index <= MAX_INT16 ? new Stownbyindex(new Imm(0), obj, new Imm(index)) :
+                                new WideStownbyindex(obj, new Imm(index));
 }
 
 export function storeOwnByValue(obj: VReg, value: VReg, nameSetting: boolean) {
-    return nameSetting ? new EcmaStownbyvaluewithnameset(obj, value) : new EcmaStownbyvalue(obj, value);
+    return nameSetting ? new Stownbyvaluewithnameset(new Imm(0), obj, value) :
+                         new Stownbyvalue(new Imm(0), obj, value);
 }
 
 export function throwIfSuperNotCorrectCall(num: number) {
-    return new EcmaThrowifsupernotcorrectcall(new Imm(num));
+    return new ThrowIfsupernotcorrectcall(new Imm(num));
 }
 
 export function call(args: VReg[], passThis: boolean) {
@@ -246,200 +271,218 @@ export function call(args: VReg[], passThis: boolean) {
     let insn: IRNode;
     if (!passThis) {
         switch (length) {
+            case 0:
+                insn = new Callarg0(new Imm(0));
+                break;
             case 1:
-                insn = new EcmaCallarg0dyn(args[0]);
+                insn = new Callarg1(new Imm(0), args[0]);
                 break;
             case 2:
-                insn = new EcmaCallarg1dyn(args[0], args[1]);
+                insn = new Callargs2(new Imm(0), args[0], args[1]);
                 break;
             case 3:
-                insn = new EcmaCallargs2dyn(args[0], args[1], args[2]);
-                break;
-            case 4:
-                insn = new EcmaCallargs3dyn(args[0], args[1], args[2], args[3]);
+                insn = new Callargs3(new Imm(0), args[0], args[1], args[2]);
                 break;
             default:
-                insn = new EcmaCallirangedyn(new Imm(length - 1), args);
+                insn = length <= MAX_INT8 ? new Callrange(new Imm(0), new Imm(length), args) :
+                                                  new WideCallrange(new Imm(length), args);
         }
     } else {
-        insn = new EcmaCallithisrangedyn(new Imm(length - 1), args);
+        insn = callThis(args);
     }
 
     return insn;
 }
 
+function callThis(args: Array<VReg>) {
+    let insn: IRNode;
+    let thisReg: VReg = args[0];
+    let length = args.length;
+    switch (length) {
+        case 1: {
+            insn = new Callthis0(new Imm(0), thisReg);
+            break;
+        }
+        case 2: {
+            insn = new Callthis1(new Imm(0), thisReg, args[1]);
+            break;
+        }
+        case 3: {
+            insn = new Callthis2(new Imm(0), thisReg, args[1], args[2]);
+            break;
+        }
+        case 4: {
+            insn = new Callthis3(new Imm(0), thisReg, args[1], args[2], args[3]);
+            break;
+        }
+        default: {
+            insn = (length - 1) <= MAX_INT8 ? new Callthisrange(new Imm(0), new Imm(length - 1), args) :
+                                              new WideCallthisrange(new Imm(length - 1), args);
+            break;
+        }
+    }
+    return insn;
+}
+
 export function newObject(args: VReg[]) {
-    return new EcmaNewobjdynrange(new Imm(args.length), args);
+    let length = args.length;
+    return length <= MAX_INT8 ? new Newobjrange(new Imm(0), new Imm(length), args) :
+                                new WideNewobjrange(new Imm(length), args);
 }
 
 export function getPropIterator() {
-    return new EcmaGetpropiterator();
+    return new Getpropiterator();
 }
 
 export function getNextPropName(iter: VReg) {
-    return new EcmaGetnextpropname(iter);
+    return new Getnextpropname(iter);
 }
 
 export function returnUndefined() {
-    return new EcmaReturnundefined();
+    return new Returnundefined();
 }
 
 export function createEmptyObject() {
-    return new EcmaCreateemptyobject();
-}
-
-export function createObjectHavingMethod(idx: number) {
-    return new EcmaCreateobjecthavingmethod(new Imm(idx));
+    return new Createemptyobject();
 }
 
 export function createObjectWithBuffer(idx: number) {
-    return new EcmaCreateobjectwithbuffer(new Imm(idx));
+    let litId: string = idx.toString();
+    return new Createobjectwithbuffer(new Imm(0), litId);
 }
 
-export function setObjectWithProto(proto: VReg, object: VReg) {
-    return new EcmaSetobjectwithproto(proto, object);
+export function setObjectWithProto(proto: VReg) {
+    return new Setobjectwithproto(new Imm(0), proto);
 }
 
-export function copyDataProperties(dstObj: VReg, srcObj: VReg) {
-    return new EcmaCopydataproperties(dstObj, srcObj);
+export function copyDataProperties(dstObj: VReg) {
+    return new Copydataproperties(dstObj);
 }
 
 export function defineGetterSetterByValue(obj: VReg, name: VReg, getter: VReg, setter: VReg) {
-    return new EcmaDefinegettersetterbyvalue(obj, name, getter, setter);
+    return new Definegettersetterbyvalue(obj, name, getter, setter);
 }
 
 export function createEmptyArray() {
-    return new EcmaCreateemptyarray();
+    return new Createemptyarray(new Imm(0));
 }
 
 export function createArrayWithBuffer(idx: number) {
-    return new EcmaCreatearraywithbuffer(new Imm(idx));
+    let litId: string = idx.toString();
+    return new Createarraywithbuffer(new Imm(0), litId);
 }
 
 export function storeArraySpread(array: VReg, index: VReg) {
-    return new EcmaStarrayspread(array, index);
+    return new Starrayspread(array, index);
 }
 
-export function defineClassWithBuffer(id: string, idx: number, parameterLength: number, env: VReg, base: VReg) {
-    return new EcmaDefineclasswithbuffer(id, new Imm(idx), new Imm(parameterLength), env, base);
+export function defineClassWithBuffer(id: string, idx: number, parameterLength: number, base: VReg) {
+    let litId: string = idx.toString();
+    return new Defineclasswithbuffer(new Imm(0), id, litId, new Imm(parameterLength), base);
 }
 
 export function createObjectWithExcludedKeys(obj: VReg, args: VReg[]) {
-    return new EcmaCreateobjectwithexcludedkeys(new Imm(args.length - 1), obj, args);
+    let followedArgs = args.length - 1;
+    return followedArgs <= MAX_INT8 ? new Createobjectwithexcludedkeys(new Imm(followedArgs), obj, args) :
+                                      new WideCreateobjectwithexcludedkeys(new Imm(followedArgs), obj, args);
 }
 
 export function throwObjectNonCoercible() {
-    return new EcmaThrowpatternnoncoercible();
+    return new ThrowPatternnoncoercible();
 }
 
 export function throwIfNotObject(v: VReg) {
-    return new EcmaThrowifnotobject(v);
+    return new ThrowIfnotobject(v);
 }
 
 export function getIterator() {
-    return new EcmaGetiterator();
+    return new Getiterator(new Imm(0));
 }
 
-export function getIteratorNext(iter: VReg, nextMethod: VReg) {
-    return new EcmaGetiteratornext(iter, nextMethod);
+export function closeIterator(iter: VReg) {
+    return new Closeiterator(new Imm(0), iter);
 }
 
-export function closeIterator(iter: VReg) {
-    return new EcmaCloseiterator(iter);
+export function superCall(num: number, args: Array<VReg>) {
+    return num <= MAX_INT8 ? new Supercallthisrange(new Imm(0), new Imm(num), args) :
+                             new WideSupercallthisrange(new Imm(num), args);
 }
 
-export function superCall(num: number, start: VReg) {
-    return new EcmaSupercall(new Imm(num), start);
+export function superCallInArrow(num: number, args: Array<VReg>) {
+    return num <= MAX_INT8 ? new Supercallarrowrange(new Imm(0), new Imm(num), args) :
+                             new WideSupercallarrowrange(new Imm(num), args);
 }
 
 export function superCallSpread(vs: VReg) {
-    return new EcmaSupercallspread(vs);
+    return new Supercallspread(new Imm(0), vs);
 }
 
-export function ldSuperByName(obj: VReg, key: string) {
-    return new EcmaLdsuperbyname(key, obj);
+export function ldSuperByName(key: string) {
+    return new Ldsuperbyname(new Imm(0), key); // obj is in acc
 }
 
 export function stSuperByName(obj: VReg, key: string) {
-    return new EcmaStsuperbyname(key, obj);
+    return new Stsuperbyname(new Imm(0), key, obj);
 }
 
 export function stSuperByValue(obj: VReg, prop: VReg) {
-    return new EcmaStsuperbyvalue(obj, prop);
+    return new Stsuperbyvalue(new Imm(0), obj, prop);
 }
 
-export function ldSuperByValue(obj: VReg, prop: VReg): IRNode {
-    return new EcmaLdsuperbyvalue(obj, prop);
+export function ldSuperByValue(obj: VReg): IRNode {
+    return new Ldsuperbyvalue(new Imm(0), obj); // prop is in acc
 }
 
-export function loadModuleVariable(name: string, isLocal: number) {
-    return new EcmaLdmodulevar(name, new Imm(isLocal));
+export function loadLocalModuleVariable(index: number) {
+    return index <= MAX_INT8 ? new Ldlocalmodulevar(new Imm(index)) : new WideLdlocalmodulevar(new Imm(index));
 }
 
-export function storeModuleVariable(name: string) {
-    return new EcmaStmodulevar(name);
+export function loadExternalModuleVariable(index: number) {
+    return index <= MAX_INT8 ? new Ldexternalmodulevar(new Imm(index)) : new WideLdexternalmodulevar(new Imm(index));
 }
 
-export function getModuleNamespace(localName: string) {
-    return new EcmaGetmodulenamespace(localName);
-}
 
-export function dynamicImport(moduleSpecifier: VReg) {
-    return new EcmaDynamicimport(moduleSpecifier);
+export function dynamicImport() {
+    return new Dynamicimport();
 }
 
-export function loadHomeObject() {
-    return new EcmaLdhomeobject();
+export function storeModuleVariable(index: number) {
+    return index <= MAX_INT8 ? new Stmodulevar(new Imm(index)) : new WideStmodulevar(new Imm(index));
 }
 
-export function defineFunc(name: string, env: VReg, paramLength: number) {
-    return new EcmaDefinefuncdyn(name, new Imm(paramLength), env);
+export function getModuleNamespace(moduleRequestIdx: number) {
+    return moduleRequestIdx <= MAX_INT8 ? new Getmodulenamespace(new Imm(moduleRequestIdx)) :
+                                          new WideGetmodulenamespace(new Imm(moduleRequestIdx));
 }
 
-export function defineAsyncFunc(name: string, env: VReg, paramLength: number) {
-    return new EcmaDefineasyncfunc(name, new Imm(paramLength), env);
+export function defineFunc(name: string, paramLength: number) {
+    return new Definefunc(new Imm(0), name, new Imm(paramLength));
 }
 
-export function defineGeneratorFunc(name: string, env: VReg, paramLength: number) {
-    return new EcmaDefinegeneratorfunc(name, new Imm(paramLength), env);
-}
-
-export function defineAsyncGeneratorFunc(name: string, env: VReg, paramLength: number) {
-    return new EcmaDefineasyncgeneratorfunc(name, new Imm(paramLength), env);
-}
-
-export function defineNCFunc(name: string, env: VReg, paramLength: number) {
-    return new EcmaDefinencfuncdyn(name, new Imm(paramLength), env);
-}
-
-export function defineMethod(name: string, env: VReg, paramLength: number) {
-    return new EcmaDefinemethod(name, new Imm(paramLength), env);
+export function defineMethod(name: string, paramLength: number) {
+    return new Definemethod(new Imm(0), name, new Imm(paramLength));
 }
 
 export function isTrue() {
-    return new EcmaIstrue();
+    return new Istrue();
 }
 
 export function isFalse() {
-    return new EcmaIsfalse();
+    return new Isfalse();
 }
 
 export function createRegExpWithLiteral(pattern: string, flags: number) {
-    return new EcmaCreateregexpwithliteral(pattern, new Imm(flags));
+    return new Createregexpwithliteral(new Imm(0), pattern, new Imm(flags));
 }
 
-export function stLetToGlobalRecord(name: string) {
-    return new EcmaStlettoglobalrecord(name);
+export function stLetOrClassToGlobalRecord(name: string) {
+    return new Sttoglobalrecord(new Imm(0), name);
 }
 
 export function stConstToGlobalRecord(name: string) {
-    return new EcmaStconsttoglobalrecord(name);
-}
-
-export function stClassToGlobalRecord(name: string) {
-    return new EcmaStclasstoglobalrecord(name);
+    return new Stconsttoglobalrecord(new Imm(0), name);
 }
 
 export function loadAccumulatorBigInt(value: string): IRNode {
-    return new EcmaLdbigint(value);
+    return new Ldbigint(value);
 }
\ No newline at end of file
diff --git a/ts2panda/src/base/builtIn.ts b/ts2panda/src/base/builtIn.ts
index 160b5f9d2a961ffbc2ba182b0fc64dc61772ead9..62c716d9fb9f0a05fde1543d64c922d4e9d789c1 100644
--- a/ts2panda/src/base/builtIn.ts
+++ b/ts2panda/src/base/builtIn.ts
@@ -16,96 +16,96 @@
 import { PandaGen } from "src/pandagen";
 import {
     IRNode,
-    EcmaLdfalse,
-    EcmaLdglobal,
-    EcmaLdhole,
-    EcmaLdinfinity,
-    EcmaLdnan,
-    EcmaLdnull,
-    EcmaLdsymbol,
-    EcmaLdtrue,
-    EcmaLdundefined,
-    StaDyn,
-    EcmaLdfunction
+    Ldfalse,
+    Ldglobal,
+    Ldhole,
+    Ldinfinity,
+    Ldnan,
+    Ldnull,
+    Ldsymbol,
+    Ldtrue,
+    Ldundefined,
+    Sta,
+    Ldfunction
 } from "../irnodes";
 import { CacheList, getVregisterCache } from "./vregisterCache";
 
 export function expandHole(pandaGen: PandaGen): IRNode[] {
     let vreg = getVregisterCache(pandaGen, CacheList.HOLE);
     return [
-        new EcmaLdhole(),
-        new StaDyn(vreg)
+        new Ldhole(),
+        new Sta(vreg)
     ]
 }
 
 export function expandNaN(pandaGen: PandaGen): IRNode[] {
     let vreg = getVregisterCache(pandaGen, CacheList.NaN);
     return [
-        new EcmaLdnan(),
-        new StaDyn(vreg)
+        new Ldnan(),
+        new Sta(vreg)
     ];
 }
 
 export function expandInfinity(pandaGen: PandaGen): IRNode[] {
     let vreg = getVregisterCache(pandaGen, CacheList.Infinity);
     return [
-        new EcmaLdinfinity(),
-        new StaDyn(vreg)
+        new Ldinfinity(),
+        new Sta(vreg)
     ];
 }
 
 export function expandGlobal(pandaGen: PandaGen): IRNode[] {
     let vreg = getVregisterCache(pandaGen, CacheList.Global);
     return [
-        new EcmaLdglobal(),
-        new StaDyn(vreg)
+        new Ldglobal(),
+        new Sta(vreg)
     ];
 }
 
 export function expandUndefined(pandaGen: PandaGen): IRNode[] {
     let vreg = getVregisterCache(pandaGen, CacheList.undefined);
     return [
-        new EcmaLdundefined(),
-        new StaDyn(vreg)
+        new Ldundefined(),
+        new Sta(vreg)
     ];
 }
 
 export function expandSymbol(pandaGen: PandaGen): IRNode[] {
     let vreg = getVregisterCache(pandaGen, CacheList.Symbol);
     return [
-        new EcmaLdsymbol(),
-        new StaDyn(vreg)
+        new Ldsymbol(),
+        new Sta(vreg)
     ];
 }
 
 export function expandNull(pandaGen: PandaGen): IRNode[] {
     let vreg = getVregisterCache(pandaGen, CacheList.Null);
     return [
-        new EcmaLdnull(),
-        new StaDyn(vreg)
+        new Ldnull(),
+        new Sta(vreg)
     ];
 }
 
 export function expandTrue(pandaGen: PandaGen): IRNode[] {
     let vreg = getVregisterCache(pandaGen, CacheList.True);
     return [
-        new EcmaLdtrue(),
-        new StaDyn(vreg)
+        new Ldtrue(),
+        new Sta(vreg)
     ];
 }
 
 export function expandFalse(pandaGen: PandaGen): IRNode[] {
     let vreg = getVregisterCache(pandaGen, CacheList.False);
     return [
-        new EcmaLdfalse(),
-        new StaDyn(vreg)
+        new Ldfalse(),
+        new Sta(vreg)
     ];
 }
 
 export function expandFunc(pandaGen: PandaGen): IRNode[] {
     let vreg = getVregisterCache(pandaGen, CacheList.FUNC);
     return [
-        new EcmaLdfunction(),
-        new StaDyn(vreg)
+        new Ldfunction(),
+        new Sta(vreg)
     ];
 }
\ No newline at end of file
diff --git a/ts2panda/src/base/iterator.ts b/ts2panda/src/base/iterator.ts
index b1d5efcee726673855de2de2e6b8c0ba11178658..465ff61a75564ca8ef7e88ced7a0e5700196a860 100644
--- a/ts2panda/src/base/iterator.ts
+++ b/ts2panda/src/base/iterator.ts
@@ -54,7 +54,7 @@ export class Iterator {
      *  }
      */
     callNext(iterResult: VReg) {
-        this.pandaGen.getIteratorNext(this.node, this.iterRecord.iterator, this.iterRecord.nextMethod);
+        this.pandaGen.call(this.node, [this.iterRecord.nextMethod, this.iterRecord.iterator], true);
         this.pandaGen.storeAccumulator(this.node, iterResult);
     }
 
diff --git a/ts2panda/src/base/lexEnv.ts b/ts2panda/src/base/lexEnv.ts
index c52373900c631a4319a79b37151209193043fcf2..a6e91703c4445ceb6e93702b2020fe6abc3c1b9d 100644
--- a/ts2panda/src/base/lexEnv.ts
+++ b/ts2panda/src/base/lexEnv.ts
@@ -20,7 +20,6 @@ import {
 import { PandaGen } from "../pandagen";
 import { VariableScope } from "../scope";
 import {
-    loadLexicalEnv,
     newLexicalEnv,
     storeAccumulator
 } from "./bcGenUtil";
@@ -43,16 +42,6 @@ function createLexEnv(pandaGen: PandaGen, scope: VariableScope): IRNode[] {
     return insns;
 }
 
-function loadLexEnv(pandaGen: PandaGen): IRNode[] {
-    let insns: IRNode[] = [];
-
-    insns.push(
-        loadLexicalEnv(),
-        storeAccumulator(getVregisterCache(pandaGen, CacheList.LexEnv)),
-    );
-    return insns;
-}
-
 export function expandLexEnv(pandaGen: PandaGen): IRNode[] {
     let scope = pandaGen.getScope()!.getNearestVariableScope();
     let insns: IRNode[];
@@ -63,8 +52,6 @@ export function expandLexEnv(pandaGen: PandaGen): IRNode[] {
 
     if (scope.need2CreateLexEnv()) {
         insns = createLexEnv(pandaGen, scope);
-    } else {
-        insns = loadLexEnv(pandaGen);
     }
 
     return insns;
diff --git a/ts2panda/src/base/util.ts b/ts2panda/src/base/util.ts
index 7f2742eb4a8cfbc18421931aed8891b55c95a090..0e0fcf46aab967f05e80c1bcf4c1e18058c5b8d3 100644
--- a/ts2panda/src/base/util.ts
+++ b/ts2panda/src/base/util.ts
@@ -17,11 +17,19 @@ import * as path from "path";
 import { extractCtorOfClass } from "../statement/classStatement";
 import * as ts from "typescript";
 import {
-    EcmaCallirangedyn,
-    EcmaCallithisrangedyn,
-    EcmaCreateobjectwithexcludedkeys,
-    EcmaNewobjdynrange,
-    IRNode
+    Callrange,
+    Callthisrange,
+    Createobjectwithexcludedkeys,
+    Newobjrange,
+    IRNode,
+    WideCallthisrange,
+    WideCallrange,
+    WideCreateobjectwithexcludedkeys,
+    Supercallthisrange,
+    WideSupercallthisrange,
+    Supercallarrowrange,
+    WideSupercallarrowrange,
+    WideNewobjrange
 } from "../irnodes";
 import * as jshelpers from "../jshelpers";
 import { LOGD } from "../log";
@@ -225,20 +233,52 @@ export function listenErrorEvent(child: any) {
 }
 
 export function isRangeInst(ins: IRNode) {
-    if (ins instanceof EcmaCallithisrangedyn ||
-        ins instanceof EcmaCallirangedyn ||
-        ins instanceof EcmaNewobjdynrange ||
-        ins instanceof EcmaCreateobjectwithexcludedkeys) {
+    if (ins instanceof Callthisrange ||
+        ins instanceof WideCallthisrange ||
+        ins instanceof Callrange ||
+        ins instanceof WideCallrange ||
+        ins instanceof Newobjrange ||
+        ins instanceof WideNewobjrange ||
+        ins instanceof Createobjectwithexcludedkeys ||
+        ins instanceof WideCreateobjectwithexcludedkeys ||
+        ins instanceof Supercallthisrange ||
+        ins instanceof WideSupercallthisrange ||
+        ins instanceof Supercallarrowrange ||
+        ins instanceof WideSupercallarrowrange) {
         return true;
     }
     return false;
 }
 
+export function getRangeStartVregPos(ins: IRNode): number {
+    if (!isRangeInst(ins)) {
+        return -1;
+    }
+
+    if (ins instanceof Callthisrange ||
+        ins instanceof Callrange ||
+        ins instanceof Newobjrange ||
+        ins instanceof Supercallthisrange ||
+        ins instanceof Supercallarrowrange ||
+        ins instanceof Createobjectwithexcludedkeys ||
+        ins instanceof WideCreateobjectwithexcludedkeys) {
+        return 2;
+    }
+
+    if (ins instanceof WideCallthisrange ||
+        ins instanceof WideCallrange ||
+        ins instanceof WideNewobjrange ||
+        ins instanceof WideSupercallthisrange ||
+        ins instanceof WideSupercallarrowrange) {
+        return 1;
+    }
+}
+
 export function getRangeExplicitVregNums(ins: IRNode): number {
     if (!isRangeInst(ins)) {
         return -1;
     }
-    return ins instanceof EcmaCreateobjectwithexcludedkeys ? 2 : 1;
+    return ins instanceof Createobjectwithexcludedkeys ? 2 : 1;
 }
 
 export function isRestParameter(parameter: ts.ParameterDeclaration) {
@@ -281,13 +321,6 @@ export function getParameterLength4Ctor(node: ts.ClassLikeDeclaration) {
     return getParamLengthOfFunc(ctorNode!);
 }
 
-export function getRangeStartVregPos(ins: IRNode): number {
-    if (!isRangeInst(ins)) {
-        return -1;
-    }
-    return ins instanceof EcmaCreateobjectwithexcludedkeys ? 2 : 1;
-}
-
 export function setPos(node: ts.Node) {
     ts.setTextRange(node, {pos:-1, end:-1});
     node.forEachChild(childNode => {
@@ -355,3 +388,6 @@ export function hasAbstractModifier(node: ts.Node): boolean {
     }
     return false;
 }
+
+export const MAX_INT8 = 127;
+export const MAX_INT16 = 32767;
\ No newline at end of file
diff --git a/ts2panda/src/base/vregisterCache.ts b/ts2panda/src/base/vregisterCache.ts
index b9a4cb34d1c2ebf8a78900d0bf762ca227db1421..4bbb061f742c8ecf6d4253e1b36814e94a14237c 100644
--- a/ts2panda/src/base/vregisterCache.ts
+++ b/ts2panda/src/base/vregisterCache.ts
@@ -18,25 +18,20 @@ import {
 } from "../irnodes";
 import { PandaGen } from "../pandagen";
 import {
-    // expandBigInt,
-    // expandBoolean,
     expandFalse,
-    // expandFunction,
     expandGlobal,
     expandHole,
     expandInfinity,
     expandNaN,
     expandNull,
-    // expandNumber,
-    // expandObject,
-    // expandRegExp,
-    // expandString,
     expandSymbol,
     expandTrue,
     expandUndefined,
     expandFunc
 } from "./builtIn";
 import { expandLexEnv } from "./lexEnv";
+
+
 export enum CacheList {
     MIN,
     NaN = MIN,
@@ -47,7 +42,7 @@ export enum CacheList {
     Symbol,
     Null,
     Global,
-    LexEnv, // Lex Env must come before True and False, because LexEnv depends on True and False
+    LexEnv,
     True,
     False,
     MAX
diff --git a/ts2panda/src/compiler.ts b/ts2panda/src/compiler.ts
index a9d9f422c5edc589dffcbf334d29efe45b2fdbfb..6a781f7eb99e1347d2f921c99c9b19971b9d44bb 100644
--- a/ts2panda/src/compiler.ts
+++ b/ts2panda/src/compiler.ts
@@ -152,7 +152,10 @@ export class Compiler {
 
         // spare v3 to save the currrent lexcial env
         getVregisterCache(this.pandaGen, CacheList.LexEnv);
-        this.envUnion.push(getVregisterCache(this.pandaGen, CacheList.LexEnv));
+        // this.envUnion.push(getVregisterCache(this.pandaGen, CacheList.LexEnv));
+        // if ((<VariableScope>(this.scope)).need2CreateLexEnv()) {
+        //     this.pandaGen.newLexicalEnv(NodeKind.FirstNodeOfFunction, (<VariableScope>(this.scope)).getNumLexEnv());
+        // }
 
         this.pandaGen.loadAccFromArgs(this.rootNode);
     }
@@ -812,7 +815,8 @@ export class Compiler {
 
     private compileExportAssignment(stmt: ts.ExportAssignment) {
         this.compileExpression(stmt.expression);
-        this.pandaGen.storeModuleVariable(stmt, "*default*");
+        this.pandaGen.storeModuleVariable(
+            stmt, (<ModuleVariable>this.pandaGen.getScope().findLocal("*default*")).getIndex());
     }
 
     compileCondition(expr: ts.Expression, ifFalseLabel: Label) {
@@ -1093,8 +1097,7 @@ export class Compiler {
 
     private compileFunctionExpression(expr: ts.FunctionExpression) {
         let internalName = this.compilerDriver.getFuncInternalName(expr, this.recorder);
-        let env = this.getCurrentEnv();
-        this.pandaGen.defineFunction(expr, expr, internalName, env);
+        this.pandaGen.defineFunction(expr, expr, internalName);
     }
 
     private compileDeleteExpression(expr: ts.DeleteExpression) {
@@ -1111,12 +1114,9 @@ export class Compiler {
                 if (!v || ((scope instanceof GlobalScope) && (v instanceof GlobalVariable))) {
                     // If the variable doesn't exist or if it is global, we must generate
                     // a delete global property instruction.
-                    let variableReg = pandaGen.getTemp();
                     objReg = getVregisterCache(pandaGen, CacheList.Global);
                     pandaGen.loadAccumulatorString(unaryExpr, name);
-                    pandaGen.storeAccumulator(unaryExpr, variableReg);
-                    pandaGen.deleteObjProperty(expr, objReg, variableReg);
-                    pandaGen.freeTemps(variableReg);
+                    pandaGen.deleteObjProperty(expr, objReg);
                 } else {
                     // Otherwise it is a local variable which can't be deleted and we just
                     // return false.
@@ -1139,17 +1139,16 @@ export class Compiler {
                 switch (typeof prop) {
                     case "string":
                         pandaGen.loadAccumulatorString(expr, prop);
-                        pandaGen.storeAccumulator(expr, propReg);
                         break;
                     case "number":
                         pandaGen.loadAccumulatorInt(expr, prop);
-                        pandaGen.storeAccumulator(expr, propReg);
                         break;
                     default:
+                        pandaGen.loadAccumulator(expr, prop);
                         break;
                 }
 
-                pandaGen.deleteObjProperty(expr, objReg, propReg);
+                pandaGen.deleteObjProperty(expr, objReg);
                 pandaGen.freeTemps(objReg, propReg);
                 break;
             }
@@ -1358,8 +1357,7 @@ export class Compiler {
 
     private compileArrowFunction(expr: ts.ArrowFunction) {
         let internalName = this.compilerDriver.getFuncInternalName(expr, this.recorder);
-        let env = this.getCurrentEnv();
-        this.pandaGen.defineFunction(expr, expr, internalName, env);
+        this.pandaGen.defineFunction(expr, expr, internalName);
     }
 
     private compileTemplateSpan(expr: ts.TemplateSpan) {
@@ -1550,7 +1548,7 @@ export class Compiler {
                 variable.v.initialize();
                 if (variable.scope instanceof GlobalScope) {
                     if (variable.v.isLet()) {
-                        this.pandaGen.stLetToGlobalRecord(node, variable.v.getName());
+                        this.pandaGen.stLetOrClassToGlobalRecord(node, variable.v.getName());
                     } else {
                         this.pandaGen.stConstToGlobalRecord(node, variable.v.getName());
                     }
@@ -1606,7 +1604,7 @@ export class Compiler {
                 let holeReg = this.pandaGen.getTemp();
                 let nameReg = this.pandaGen.getTemp();
                 this.pandaGen.storeAccumulator(node, valueReg);
-                this.pandaGen.loadModuleVariable(node, variable.v.getName(), true);
+                this.pandaGen.loadModuleVariable(node, variable.v.getIndex(), true);
                 this.pandaGen.storeAccumulator(node, holeReg);
                 this.pandaGen.loadAccumulatorString(node, variable.v.getName());
                 this.pandaGen.storeAccumulator(node, nameReg);
@@ -1615,7 +1613,7 @@ export class Compiler {
                 this.pandaGen.freeTemps(valueReg, holeReg, nameReg);
             }
 
-            this.pandaGen.storeModuleVariable(node, variable.v.getName());
+            this.pandaGen.storeModuleVariable(node, variable.v.getIndex());
         } else {
             throw new Error("invalid lhsRef to store");
         }
@@ -1663,7 +1661,7 @@ export class Compiler {
             }
         } else if (variable.v instanceof ModuleVariable) {
             let isLocal: boolean = variable.v.isExportVar() ? true : false;
-            this.pandaGen.loadModuleVariable(node, variable.v.getName(), isLocal);
+            this.pandaGen.loadModuleVariable(node, variable.v.getIndex(), isLocal);
             if ((variable.v.isLetOrConst() || variable.v.isClass()) && !variable.v.isInitialized()) {
                 let valueReg = this.pandaGen.getTemp();
                 let nameReg = this.pandaGen.getTemp();
diff --git a/ts2panda/src/compilerDriver.ts b/ts2panda/src/compilerDriver.ts
index 934449b3a2c3ab9636efe4441ceab5a9540e58f6..71b25065c0723984986fda6e23059321abcdecf9 100644
--- a/ts2panda/src/compilerDriver.ts
+++ b/ts2panda/src/compilerDriver.ts
@@ -17,7 +17,10 @@ import { writeFileSync } from "fs";
 import * as ts from "typescript";
 import { addVariableToScope } from "./addVariable2Scope";
 import { AssemblyDumper } from "./assemblyDumper";
-import { hasDefaultKeywordModifier, hasExportKeywordModifier, initiateTs2abc, listenChildExit, listenErrorEvent, terminateWritePipe, getRecordTypeFlag } from "./base/util";
+import {
+    hasDefaultKeywordModifier, hasExportKeywordModifier, initiateTs2abc, listenChildExit,
+    listenErrorEvent, terminateWritePipe, getRecordTypeFlag
+} from "./base/util";
 import { CmdOptions } from "./cmdOptions";
 import {
     Compiler
@@ -26,7 +29,7 @@ import { CompilerStatistics } from "./compilerStatistics";
 import { DebugInfo } from "./debuginfo";
 import { hoisting } from "./hoisting";
 import { LOGD } from "./log";
-import { setModuleNamespaceImports } from "./ecmaModule";
+import { setModuleNamespaceImports, assignIndexToModuleVariable } from "./ecmaModule";
 import { PandaGen } from "./pandagen";
 import { Pass } from "./pass";
 import { CacheExpander } from "./pass/cacheExpander";
@@ -45,6 +48,7 @@ import { Ts2Panda } from "./ts2panda";
 import { TypeRecorder } from "./typeRecorder";
 import { LiteralBuffer } from "./base/literal";
 import { findOuterNodeOfParenthesis } from "./expression/parenthesizedExpression";
+import { IRNode } from "./irnodes";
 
 export class PendingCompilationUnit {
     constructor(
@@ -218,7 +222,9 @@ export class CompilerDriver {
 
     private compileImpl(node: ts.SourceFile | ts.FunctionLikeDeclaration, scope: Scope,
         internalName: string, recorder: Recorder): void {
+
         let pandaGen = new PandaGen(internalName, node, this.getParametersCount(node), scope);
+        IRNode.pg = pandaGen;
 
         if (CmdOptions.needRecordSourceCode() && !ts.isSourceFile(node)) {
             // souceCode of [ts.sourceFile] will be record in debugInfo later.
@@ -310,6 +316,7 @@ export class CompilerDriver {
             topLevelScope.module().setModuleEnvironment(topLevelScope);
         }
         addVariableToScope(recorder, enableTypeRecord);
+        assignIndexToModuleVariable(topLevelScope);
 
         let postOrderVariableScopes = this.postOrderAnalysis(topLevelScope);
 
diff --git a/ts2panda/src/compilerStatistics.ts b/ts2panda/src/compilerStatistics.ts
index 5fd1d08069035c96b05f42bc6808ba8b5d28c4cb..25fda2b8908e65105ce82fc3233e7d5986ad0058 100644
--- a/ts2panda/src/compilerStatistics.ts
+++ b/ts2panda/src/compilerStatistics.ts
@@ -124,11 +124,11 @@ class HistogramStatistics {
             return "Label"
         }
 
-        if ((ins.kind == IRNodeKind.CALL) || (ins.kind == IRNodeKind.CALL_SHORT) || (ins.kind == IRNodeKind.CALL_RANGE)) {
-            let mnemonic = <string>ins.operands[0];
-            let part = mnemonic.split('.');
-            return part[2];
-        }
+        // if ((ins.kind == IRNodeKind.CALL) || (ins.kind == IRNodeKind.CALL_SHORT) || (ins.kind == IRNodeKind.CALL_RANGE)) {
+        //     let mnemonic = <string>ins.operands[0];
+        //     let part = mnemonic.split('.');
+        //     return part[2];
+        // }
         return ins.getMnemonic();
     }
 
diff --git a/ts2panda/src/debuginfo.ts b/ts2panda/src/debuginfo.ts
index c2eadc911047166c3ec1b5d3116c9b6aaf99e91e..b49a58105a3a0e58a2819681e6984fdf8fd01110 100644
--- a/ts2panda/src/debuginfo.ts
+++ b/ts2panda/src/debuginfo.ts
@@ -16,13 +16,13 @@
 import * as ts from "typescript";
 import { CmdOptions } from "./cmdOptions";
 import {
-    CalliDynRange,
-    CallRange,
+    Callrange,
     DebugInsStartPlaceHolder,
     DebugInsEndPlaceHolder,
     IRNode,
     Label,
-    VReg
+    VReg,
+    WideCallrange
 } from "./irnodes";
 import * as jshelpers from "./jshelpers";
 import { PandaGen } from "./pandagen";
@@ -263,7 +263,7 @@ export class DebugInfo {
         let formats = irnode.getFormats()[formatIndex];
         // count operands length
         for (let i = 0; i < formats.length; i++) {
-            if ((irnode instanceof CalliDynRange) || (irnode instanceof CallRange)) {
+            if ((irnode instanceof WideCallrange) || (irnode instanceof Callrange)) {
                 length += formats[0][1] / 8; // 8 indicates that one byte is composed of 8 bits
                 length += formats[1][1] / 8;
                 break;
@@ -331,7 +331,7 @@ export class DebugInfo {
                 }
                 let variableInfo = new VariableDebugInfo(key, "any", "any", (value.getVreg().num));
                 variableInfo.setStart(scope.getScopeStartInsIdx());
-                variableInfo.setLength(scope.getScopeEndInsIdx() - scope.getScopeStartInsIdx());
+                variableInfo.setLength(scope.getScopeEndInsIdx() - scope.getScopeStartInsIdx() + 1);
                 pandaGen.addDebugVariableInfo(variableInfo);
             });
         });
diff --git a/ts2panda/src/ecmaModule.ts b/ts2panda/src/ecmaModule.ts
index 9ebdb38c85c98dec709012452fc3bb208b8a18b9..2013ffd3564a979de79c6d27014c7312503058c8 100644
--- a/ts2panda/src/ecmaModule.ts
+++ b/ts2panda/src/ecmaModule.ts
@@ -20,6 +20,7 @@ import { ModuleScope, Scope } from "./scope";
 import { getSourceFileOfNode } from "./jshelpers";
 import { LReference } from "./base/lreference";
 import { Compiler } from "./compiler";
+import { ModuleVariable } from "./variable";
 
 class Entry {
     node: ts.Node;
@@ -234,7 +235,23 @@ export function setModuleNamespaceImports(compiler: Compiler, moduleScope: Scope
 
     moduleScope.module().getNamespaceImportEntries().forEach(entry => {
         let namespace_lref = LReference.generateLReference(compiler, (<ts.NamespaceImport>entry.node).name, true);
-        pandagen.getModuleNamespace(entry.node, entry.localName!);
+        pandagen.getModuleNamespace(entry.node, entry.moduleRequest);
         namespace_lref.setValue();
     });
+}
+
+export function assignIndexToModuleVariable(moduleScope: Scope) {
+    if (!(moduleScope instanceof ModuleScope)) {
+        return;
+    }
+    let index: number = 0;
+    // @ts-ignore
+    moduleScope.module().getLocalExportEntries().forEach((entries: Array<Entry>, localName: string) => {
+        (<ModuleVariable>moduleScope.findLocal(localName)!).assignIndex(index++);
+    });
+    index = 0;
+    // @ts-ignore
+    moduleScope.module().getRegularImportEntries().forEach((entry: Entry, localName: string) => {
+        (<ModuleVariable>moduleScope.findLocal(localName)!).assignIndex(index++);
+    });
 }
\ No newline at end of file
diff --git a/ts2panda/src/expression/callExpression.ts b/ts2panda/src/expression/callExpression.ts
index 77bdfb9b617ef7770db2d50679c98784fc7e7af2..334a6a4a25c11e74d0da2ce89f54a17dfcbf3592 100644
--- a/ts2panda/src/expression/callExpression.ts
+++ b/ts2panda/src/expression/callExpression.ts
@@ -28,11 +28,8 @@ export function compileCallExpression(expr: ts.CallExpression, compiler: Compile
     let pandaGen = compiler.getPandaGen();
 
     if (expr.expression.kind == ts.SyntaxKind.ImportKeyword) {
-        let moduleSpecifierReg = pandaGen.getTemp();
         compiler.compileExpression(expr.arguments[0]);
-        pandaGen.storeAccumulator(expr.arguments[0], moduleSpecifierReg);
-        pandaGen.dynamicImportCall(expr, moduleSpecifierReg);
-        pandaGen.freeTemps(moduleSpecifierReg);
+        pandaGen.dynamicImportCall(expr);
         return;
     }
 
diff --git a/ts2panda/src/expression/newExpression.ts b/ts2panda/src/expression/newExpression.ts
index 653d6eef4536e450984ba9bc50954e45941db195..4f05d929dbb3792dbcb1c4d982e5f61b34468426 100644
--- a/ts2panda/src/expression/newExpression.ts
+++ b/ts2panda/src/expression/newExpression.ts
@@ -22,36 +22,31 @@ import { createArrayFromElements } from "./arrayLiteralExpression";
 export function compileNewExpression(expr: ts.NewExpression, compiler: Compiler) {
     let pandaGen = compiler.getPandaGen();
     let ctorReg = pandaGen.getTemp();
-    let newTargetReg = pandaGen.getTemp();
 
     // get the ctor function
     compiler.compileExpression(expr.expression);
     pandaGen.storeAccumulator(expr, ctorReg);
 
-    // new.target will be the same as ctor
-    pandaGen.moveVreg(expr, newTargetReg, ctorReg);
-
     if (containSpreadElement(expr.arguments)) {
         let argRegs = pandaGen.getTemp();
         createArrayFromElements(expr, compiler, <ts.NodeArray<ts.Expression>>expr.arguments, argRegs);
 
-        pandaGen.newObjSpread(expr, ctorReg, newTargetReg);
-        pandaGen.freeTemps(ctorReg, newTargetReg, argRegs);
+        pandaGen.newObjSpread(expr, ctorReg);
+        pandaGen.freeTemps(ctorReg, argRegs);
 
         return;
     }
 
     // prepare arguments for newobj.dyn.range instruction
-    let numArgs = 2; // for the ctor
+    let numArgs = 1; // for the ctor
     if (expr.arguments) {
         numArgs += expr.arguments.length;
     }
 
     let argRegs = new Array<VReg>(numArgs);
     argRegs[0] = ctorReg;
-    argRegs[1] = newTargetReg;
 
-    let argIndex = 2;
+    let argIndex = 1;
     if (expr.arguments) {
         // store ctor arguments in registers
         expr.arguments.forEach((argExpr: ts.Expression) => {
diff --git a/ts2panda/src/expression/objectLiteralExpression.ts b/ts2panda/src/expression/objectLiteralExpression.ts
index b7f34f646dd7f74a5c15af4082a60ae79b34520a..aec9baf441e34f9c7286cd5684ad1d3f6be5b408 100644
--- a/ts2panda/src/expression/objectLiteralExpression.ts
+++ b/ts2panda/src/expression/objectLiteralExpression.ts
@@ -115,12 +115,7 @@ function createObject(expr: ts.ObjectLiteralExpression, pandaGen: PandaGen, objR
         let literalArrayBuffer = PandaGen.getLiteralArrayBuffer();
         let bufferIdx = literalArrayBuffer.length;
         literalArrayBuffer.push(literalBuffer);
-        if (hasMethod) {
-            let env = compiler.getCurrentEnv();
-            pandaGen.createObjectHavingMethod(expr, bufferIdx, env);
-        } else {
-            pandaGen.createObjectWithBuffer(expr, bufferIdx);
-        }
+        pandaGen.createObjectWithBuffer(expr, bufferIdx);
     }
     pandaGen.storeAccumulator(expr, objReg);
 }
@@ -188,11 +183,9 @@ function compileAccessorProperty(pandaGen: PandaGen, compiler: Compiler, objReg:
 function compileSpreadProperty(compiler: Compiler, prop: Property, objReg: VReg) {
     let pandaGen = compiler.getPandaGen();
 
-    let srcObj = pandaGen.getTemp();
     compiler.compileExpression(<ts.Expression>prop.getValue());
-    pandaGen.storeAccumulator(<ts.Expression>prop.getValue(), srcObj);
-    pandaGen.copyDataProperties(<ts.Expression>prop.getValue().parent, objReg, srcObj);
-    pandaGen.freeTemps(srcObj);
+    // srcObj is in acc now
+    pandaGen.copyDataProperties(<ts.Expression>prop.getValue().parent, objReg);
 }
 
 function compileComputedProperty(compiler: Compiler, prop: Property, objReg: VReg) {
@@ -293,11 +286,10 @@ function setUncompiledProperties(compiler: Compiler, pandaGen: PandaGen, propert
 export function createMethodOrAccessor(pandaGen: PandaGen, compiler: Compiler, objReg: VReg,
                                        func: ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.ConstructorDeclaration) {
     let internalName = compiler.getCompilerDriver().getFuncInternalName(func, compiler.getRecorder());
-    let env = compiler.getCurrentEnv();
     if (ts.isMethodDeclaration(func) && func.asteriskToken) {
-        pandaGen.defineFunction(func, func, internalName, env);
+        pandaGen.defineFunction(func, func, internalName);
     } else {
-        pandaGen.defineMethod(func, internalName, objReg, env);
+        pandaGen.defineMethod(func, internalName, objReg);
     }
 }
 
diff --git a/ts2panda/src/function/asyncFunctionBuilder.ts b/ts2panda/src/function/asyncFunctionBuilder.ts
index b38543fa6c0a81fe0890e9d40f132e5ea0fa9887..bf0a9e66ed91b1a9e6ce9d06d17848e25086605d 100644
--- a/ts2panda/src/function/asyncFunctionBuilder.ts
+++ b/ts2panda/src/function/asyncFunctionBuilder.ts
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+import { loadAccumulator } from "src/base/bcGenUtil";
 import * as ts from "typescript";
 import { CacheList, getVregisterCache } from "../base/vregisterCache";
 import { NodeKind } from "../debuginfo";
@@ -58,10 +59,10 @@ export class AsyncFunctionBuilder {
         let pandaGen = this.pandaGen;
         let promise = this.pandaGen.getTemp();
 
-        pandaGen.asyncFunctionAwaitUncaught(node, this.asyncObj, value);
-        pandaGen.storeAccumulator(node, promise);
+        pandaGen.loadAccumulator(node, value);
+        pandaGen.asyncFunctionAwaitUncaught(node, this.asyncObj);
 
-        pandaGen.suspendGenerator(node, this.asyncObj, promise);
+        pandaGen.suspendGenerator(node, this.asyncObj);
 
         pandaGen.freeTemps(promise);
 
@@ -97,8 +98,8 @@ export class AsyncFunctionBuilder {
 
     resolve(node: ts.Node | NodeKind, value: VReg) {
         let pandaGen = this.pandaGen;
-
-        pandaGen.asyncFunctionResolve(node, this.asyncObj, getVregisterCache(pandaGen, CacheList.True), value);
+        pandaGen.loadAccumulator(node, value);
+        pandaGen.asyncFunctionResolve(node, this.asyncObj);
     }
 
     cleanUp(node: ts.Node): void {
@@ -106,15 +107,10 @@ export class AsyncFunctionBuilder {
 
         pandaGen.label(node, this.endLabel);
 
-        // catch
-        let exception = pandaGen.getTemp();
-
-        pandaGen.storeAccumulator(NodeKind.Invalid, exception);
-        pandaGen.asyncFunctionReject(NodeKind.Invalid, this.asyncObj, getVregisterCache(pandaGen, CacheList.True), exception);
+        // exception is in acc
+        pandaGen.asyncFunctionReject(NodeKind.Invalid, this.asyncObj);
         pandaGen.return(NodeKind.Invalid);
 
-        pandaGen.freeTemps(exception);
-
         pandaGen.freeTemps(this.asyncObj, this.retVal);
 
         new CatchTable(pandaGen, this.endLabel, new LabelPair(this.beginLabel, this.endLabel));
diff --git a/ts2panda/src/function/asyncGeneratorFunctionBuilder.ts b/ts2panda/src/function/asyncGeneratorFunctionBuilder.ts
index fc10094596ed9f7782c7597961f5571a65e5fcf4..fa4dc53c489d6ad24dea9f036b17f626b990b662 100644
--- a/ts2panda/src/function/asyncGeneratorFunctionBuilder.ts
+++ b/ts2panda/src/function/asyncGeneratorFunctionBuilder.ts
@@ -55,7 +55,8 @@ export class AsyncGeneratorFunctionBuilder {
         // backend handle funcobj, frontend set undefined
         pandaGen.createAsyncGeneratorObj(node, getVregisterCache(pandaGen, CacheList.FUNC));
         pandaGen.storeAccumulator(node, this.asyncGenObj);
-        pandaGen.suspendGenerator(node, this.asyncGenObj, getVregisterCache(pandaGen, CacheList.undefined));
+        pandaGen.loadAccumulator(node, getVregisterCache(pandaGen, CacheList.undefined));
+        pandaGen.suspendGenerator(node, this.asyncGenObj);
         pandaGen.resumeGenerator(node, this.asyncGenObj);
         pandaGen.storeAccumulator(node, this.retValue);
     }
@@ -64,10 +65,10 @@ export class AsyncGeneratorFunctionBuilder {
         let pandaGen = this.asyncPandaGen;
         let promise = this.asyncPandaGen.getTemp();
 
-        pandaGen.asyncFunctionAwaitUncaught(node, this.asyncGenObj, value);
-        pandaGen.storeAccumulator(node, promise);
+        pandaGen.loadAccumulator(node, value);
+        pandaGen.asyncFunctionAwaitUncaught(node, this.asyncGenObj);
 
-        pandaGen.suspendGenerator(node, this.asyncGenObj, promise);
+        pandaGen.suspendGenerator(node, this.asyncGenObj);
 
         pandaGen.freeTemps(promise);
 
@@ -80,9 +81,8 @@ export class AsyncGeneratorFunctionBuilder {
     yield(node: ts.Node, value: VReg) {
         let pandaGen = this.asyncPandaGen;
         let promise = this.asyncPandaGen.getTemp();
-        pandaGen.EcmaAsyncgeneratorresolve(node, this.asyncGenObj, value, getVregisterCache(pandaGen, CacheList.False));
-        pandaGen.storeAccumulator(node, promise);
-        pandaGen.suspendGenerator(node, this.asyncGenObj, promise);
+        pandaGen.Asyncgeneratorresolve(node, this.asyncGenObj, value, getVregisterCache(pandaGen, CacheList.False));
+        pandaGen.suspendGenerator(node, this.asyncGenObj);
         pandaGen.freeTemps(promise);
         pandaGen.resumeGenerator(node, this.asyncGenObj);
         pandaGen.storeAccumulator(node, this.retValue);
@@ -165,18 +165,15 @@ export class AsyncGeneratorFunctionBuilder {
 
     resolve(node: ts.Node | NodeKind, value: VReg) {
         let pandaGen = this.asyncPandaGen;
-        pandaGen.EcmaAsyncgeneratorresolve(node, this.asyncGenObj, value, getVregisterCache(pandaGen, CacheList.True));
+        pandaGen.Asyncgeneratorresolve(node, this.asyncGenObj, value, getVregisterCache(pandaGen, CacheList.True));
     }
 
     cleanUp(node: ts.Node) {
         let pandaGen = this.asyncPandaGen;
         pandaGen.label(node, this.endLabel);
         // catch
-        let exception = pandaGen.getTemp();
-        pandaGen.storeAccumulator(NodeKind.Invalid, exception);
-        pandaGen.EcmaAsyncgeneratorreject(node, this.asyncGenObj, exception);
+        pandaGen.asyncgeneratorreject(node, this.asyncGenObj); // exception is in acc
         pandaGen.return(NodeKind.Invalid);
-        pandaGen.freeTemps(exception);
         this.asyncPandaGen.freeTemps(this.asyncGenObj, this.retValue);
         new CatchTable(pandaGen, this.endLabel, new LabelPair(this.beginLabel, this.endLabel));
     }
diff --git a/ts2panda/src/function/generatorFunctionBuilder.ts b/ts2panda/src/function/generatorFunctionBuilder.ts
index b7297aebd1462233cc4ef8002c0448c3d4f006cc..a3dae1c83e761392aa81bae316dd26ff68cf5b54 100644
--- a/ts2panda/src/function/generatorFunctionBuilder.ts
+++ b/ts2panda/src/function/generatorFunctionBuilder.ts
@@ -53,7 +53,8 @@ export class GeneratorFunctionBuilder {
         // backend handle funcobj, frontend set undefined
         pandaGen.createGeneratorObj(node, getVregisterCache(pandaGen, CacheList.FUNC));
         pandaGen.storeAccumulator(node, this.genObj);
-        pandaGen.suspendGenerator(node, this.genObj, getVregisterCache(pandaGen, CacheList.undefined));
+        pandaGen.loadAccumulator(node, getVregisterCache(pandaGen, CacheList.undefined));
+        pandaGen.suspendGenerator(node, this.genObj);
         pandaGen.resumeGenerator(node, this.genObj);
         pandaGen.storeAccumulator(node, this.retVal);
 
@@ -64,9 +65,8 @@ export class GeneratorFunctionBuilder {
         let pandaGen = this.pandaGen;
 
         let iterRslt = pandaGen.getTemp();
-        pandaGen.EcmaCreateiterresultobj(node, value, getVregisterCache(pandaGen, CacheList.False));
-        pandaGen.storeAccumulator(node, iterRslt);
-        pandaGen.suspendGenerator(node, this.genObj, iterRslt);
+        pandaGen.Createiterresultobj(node, value, getVregisterCache(pandaGen, CacheList.False));
+        pandaGen.suspendGenerator(node, this.genObj);
         pandaGen.freeTemps(iterRslt);
 
         pandaGen.resumeGenerator(node, this.genObj);
@@ -177,7 +177,8 @@ export class GeneratorFunctionBuilder {
         pandaGen.loadObjProperty(expr, this.retVal, "done");
         pandaGen.jumpIfTrue(expr, exitLabel_value);
 
-        pandaGen.suspendGenerator(expr, this.genObj, this.retVal);
+        pandaGen.loadAccumulator(expr, this.retVal);
+        pandaGen.suspendGenerator(expr, this.genObj);
         pandaGen.resumeGenerator(expr, this.genObj);
         pandaGen.storeAccumulator(expr, receivedValue);
         pandaGen.getResumeMode(expr, this.genObj);
diff --git a/ts2panda/src/hoisting.ts b/ts2panda/src/hoisting.ts
index 4fca6459120954f8acc9fd561a50a67ad8880c1f..71c31e57580176fa208e89241fc374913c877e59 100644
--- a/ts2panda/src/hoisting.ts
+++ b/ts2panda/src/hoisting.ts
@@ -31,6 +31,7 @@ import {
     VarDecl,
     VariableScope
 } from "./scope";
+import { ModuleVariable } from "./variable";
 
 export function hoisting(rootNode: ts.SourceFile | ts.FunctionLikeDeclaration, pandaGen: PandaGen,
     recorder: Recorder, compiler: Compiler) {
@@ -59,7 +60,7 @@ export function hoistVar(decl: VarDecl, scope: Scope, pandaGen: PandaGen) {
         let v = scope.findLocal(name)!;
         pandaGen.loadAccumulator(NodeKind.FirstNodeOfFunction, getVregisterCache(pandaGen, CacheList.undefined));
         if (decl.isModule !== ModuleVarKind.NOT) {
-            pandaGen.storeModuleVariable(NodeKind.FirstNodeOfFunction, name);
+            pandaGen.storeModuleVariable(NodeKind.FirstNodeOfFunction, (<ModuleVariable>v).getIndex());
         } else {
             pandaGen.storeAccToLexEnv(NodeKind.FirstNodeOfFunction, scope, 0, v, true);
         }
@@ -74,13 +75,13 @@ export function hoistFunction(decl: FuncDecl, scope: Scope, pandaGen: PandaGen,
     let env = compiler.getCurrentEnv();
 
     if (scope instanceof GlobalScope) {
-        pandaGen.defineFunction(NodeKind.FirstNodeOfFunction, <ts.FunctionDeclaration>decl.node, internalName, env);
+        pandaGen.defineFunction(NodeKind.FirstNodeOfFunction, <ts.FunctionDeclaration>decl.node, internalName);
         pandaGen.storeGlobalVar(NodeKind.FirstNodeOfFunction, funcName);
     } else if ((scope instanceof FunctionScope) || (scope instanceof LocalScope) || (scope instanceof ModuleScope)) {
         let v = scope.findLocal(funcName)!;
-        pandaGen.defineFunction(NodeKind.FirstNodeOfFunction, <ts.FunctionDeclaration>decl.node, internalName, env);
+        pandaGen.defineFunction(NodeKind.FirstNodeOfFunction, <ts.FunctionDeclaration>decl.node, internalName);
         if (decl.isModule !== ModuleVarKind.NOT) {
-            pandaGen.storeModuleVariable(NodeKind.FirstNodeOfFunction, funcName);
+            pandaGen.storeModuleVariable(NodeKind.FirstNodeOfFunction, (<ModuleVariable>v).getIndex());
         } else {
             pandaGen.storeAccToLexEnv(NodeKind.FirstNodeOfFunction, scope, 0, v, true);
         }
diff --git a/ts2panda/src/lexenv.ts b/ts2panda/src/lexenv.ts
index a5d2e2308ce0d3e35ecf1c04a9ba8e0589d539b2..ee896e07f6d054342b5dc5c3f8ab574faebb616d 100644
--- a/ts2panda/src/lexenv.ts
+++ b/ts2panda/src/lexenv.ts
@@ -197,7 +197,8 @@ export class VariableAcessStore extends VariableAccessBase {
             }
         }
 
-        insns.push(storeLexicalVar(this.level, slot, valueReg));
+        insns.push(loadAccumulator(valueReg));
+        insns.push(storeLexicalVar(this.level, slot));
         insns.push(loadAccumulator(valueReg));
 
         pandaGen.freeTemps(valueReg);
diff --git a/ts2panda/src/pandagen.ts b/ts2panda/src/pandagen.ts
index a89c41a6c23d8ead45b73271b1a6d22aa9028a66..ce824c54a7d26e13be6159910e9a9fa855f33a15 100644
--- a/ts2panda/src/pandagen.ts
+++ b/ts2panda/src/pandagen.ts
@@ -34,22 +34,16 @@ import {
     createArrayWithBuffer,
     createEmptyArray,
     createEmptyObject,
-    createObjectHavingMethod,
     createObjectWithBuffer,
     createObjectWithExcludedKeys,
     createRegExpWithLiteral,
-    defineAsyncFunc,
     defineClassWithBuffer,
     defineFunc,
-    defineGeneratorFunc,
-    defineAsyncGeneratorFunc,
     defineGetterSetterByValue,
     defineMethod,
-    defineNCFunc,
     deleteObjProperty,
     dynamicImport,
     getIterator,
-    getIteratorNext,
     getNextPropName,
     getPropIterator,
     getModuleNamespace,
@@ -62,10 +56,10 @@ import {
     loadAccumulatorFloat,
     loadAccumulatorInt,
     loadAccumulatorString,
+    loadExternalModuleVariable,
     loadGlobalVar,
-    loadHomeObject,
     loadLexicalVar,
-    loadModuleVariable,
+    loadLocalModuleVariable,
     loadObjByIndex,
     loadObjByName,
     loadObjByValue,
@@ -75,9 +69,8 @@ import {
     popLexicalEnv,
     returnUndefined,
     setObjectWithProto,
-    stClassToGlobalRecord,
     stConstToGlobalRecord,
-    stLetToGlobalRecord,
+    stLetOrClassToGlobalRecord,
     storeAccumulator,
     storeArraySpread,
     storeGlobalVar,
@@ -92,6 +85,7 @@ import {
     stSuperByName,
     stSuperByValue,
     superCall,
+    superCallInArrow,
     superCallSpread,
     throwConstAssignment,
     throwDeleteSuperProperty,
@@ -111,7 +105,7 @@ import {
     LiteralTag
 } from "./base/literal";
 import { BaseType } from "./base/typeSystem";
-import { getParamLengthOfFunc } from "./base/util";
+import { getParamLengthOfFunc, MAX_INT8 } from "./base/util";
 import {
     CacheList,
     getVregisterCache,
@@ -125,57 +119,58 @@ import {
 } from "./debuginfo";
 import { isInteger } from "./expression/numericLiteral";
 import {
-    EcmaAdd2dyn,
-    EcmaAnd2dyn,
-    EcmaAshr2dyn,
-    EcmaAsyncfunctionawaituncaught,
-    EcmaAsyncfunctionenter,
-    EcmaAsyncfunctionreject,
-    EcmaAsyncfunctionresolve,
-    EcmaCallspreaddyn,
-    EcmaCopyrestargs,
-    EcmaCreategeneratorobj,
-    EcmaCreateasyncgeneratorobj,
-    EcmaCreateiterresultobj,
-    EcmaAsyncgeneratorresolve,
-    EcmaAsyncgeneratorreject,
-    EcmaDecdyn,
-    EcmaDiv2dyn,
-    EcmaEqdyn,
-    EcmaExpdyn,
-    EcmaGetresumemode,
-    EcmaGettemplateobject,
-    EcmaGetunmappedargs,
-    EcmaGreaterdyn,
-    EcmaGreatereqdyn,
-    EcmaIncdyn,
-    EcmaInstanceofdyn,
-    EcmaIsindyn,
-    EcmaLessdyn,
-    EcmaLesseqdyn,
-    EcmaMod2dyn,
-    EcmaMul2dyn,
-    EcmaNegdyn,
-    EcmaNewobjspreaddyn,
-    EcmaNotdyn,
-    EcmaNoteqdyn,
-    EcmaOr2dyn,
-    EcmaResumegenerator,
-    EcmaShl2dyn,
-    EcmaShr2dyn,
-    EcmaStricteqdyn,
-    EcmaStrictnoteqdyn,
-    EcmaSub2dyn,
-    EcmaSuspendgenerator,
-    EcmaTonumber,
-    EcmaTonumeric,
-    EcmaTypeofdyn,
-    EcmaXor2dyn,
+    Asyncgeneratorreject,
+    Add2,
+    And2,
+    Ashr2,
+    Asyncfunctionawaituncaught,
+    Asyncfunctionenter,
+    Asyncfunctionreject,
+    Asyncfunctionresolve,
+    Apply,
+    Copyrestargs,
+    WideCopyrestargs,
+    Creategeneratorobj,
+    Createasyncgeneratorobj,
+    Createiterresultobj,
+    Asyncgeneratorresolve,
+    Dec,
+    Div2,
+    Eq,
+    Exp,
+    Getresumemode,
+    Gettemplateobject,
+    Getunmappedargs,
+    Greater,
+    Greatereq,
+    Inc,
+    Instanceof,
+    Isin,
+    Less,
+    Lesseq,
+    Mod2,
+    Mul2,
+    Neg,
+    Newobjapply,
+    Not,
+    Noteq,
+    Or2,
+    Resumegenerator,
+    Shl2,
+    Shr2,
+    Stricteq,
+    Strictnoteq,
+    Sub2,
+    Suspendgenerator,
+    Tonumber,
+    Tonumeric,
+    Typeof,
+    Xor2,
     Imm,
     IRNode,
     Jeqz,
     Label,
-    ReturnDyn,
+    Return,
     VReg
 } from "./irnodes";
 import {
@@ -192,7 +187,17 @@ import {
 import { CatchTable } from "./statement/tryStatement";
 import { TypeRecorder } from "./typeRecorder";
 import { Variable } from "./variable";
-
+import * as jshelpers from "./jshelpers";
+
+export enum FunctionKind {
+    NONE = 0, // represent method for now
+    FUNCTION = 1,
+    NC_FUNCTION = 2,
+    GENERATOR_FUNCTION = 3,
+    ASYNC_FUNCTION = 4,
+    ASYNC_GENERATOR_FUNCTION = 5,
+    ASYNC_NCFUNCTION = 6
+}
 export class PandaGen {
     // @ts-ignore
     private debugTag: string = "PandaGen";
@@ -213,6 +218,8 @@ export class PandaGen {
     private sourceFile: string = "";
     private sourceCode: string | undefined = undefined;
     private callType: number = 0;
+    private funcKind: FunctionKind = FunctionKind.NONE;
+    private icSize: number = 0;
 
     private static literalArrayBuffer: Array<LiteralBuffer> = new Array<LiteralBuffer>();
 
@@ -223,6 +230,7 @@ export class PandaGen {
         this.parametersCount = parametersCount;
         this.scope = scope;
         this.vregisterCache = new VregisterCache();
+        this.setFunctionKind(node);
     }
 
     public appendScopeInfo(lexVarInfo: Map<string, number>): number | undefined {
@@ -244,6 +252,52 @@ export class PandaGen {
         return scopeInfoIdx;
     }
 
+    public setFunctionKind(node: ts.SourceFile | ts.FunctionLikeDeclaration) {
+        if (ts.isSourceFile(node)) {
+            this.funcKind = FunctionKind.FUNCTION;
+            return;
+        }
+
+        if (ts.isMethodDeclaration(node)) {
+            return;
+        }
+
+        if (node.modifiers) {
+            for (let i = 0; i < node.modifiers.length; i++) {
+                if (node.modifiers[i].kind == ts.SyntaxKind.AsyncKeyword) {
+                    if (node.asteriskToken) {
+                        this.funcKind = FunctionKind.ASYNC_GENERATOR_FUNCTION;
+                        return;
+                    }
+
+                    if (ts.isArrowFunction(node)) {
+                        this.funcKind = FunctionKind.ASYNC_NCFUNCTION;
+                        return;
+                    }
+
+                    this.funcKind = FunctionKind.ASYNC_FUNCTION;
+                    return;
+                }
+            }
+        }
+
+        if (node.asteriskToken) {
+            this.funcKind = FunctionKind.GENERATOR_FUNCTION;
+            return;
+        }
+
+        if (ts.isArrowFunction(node)) {
+            this.funcKind = FunctionKind.NC_FUNCTION;
+            return;
+        }
+
+        this.funcKind = FunctionKind.FUNCTION;
+    }
+
+    public getFunctionKind() {
+        return this.funcKind;
+    }
+
     public setCallType(callType: number) {
         this.callType = callType;
     }
@@ -252,6 +306,14 @@ export class PandaGen {
         return this.callType;
     }
 
+    public updateIcSize(icSlot: number) {
+        this.icSize += icSlot;
+    }
+
+    public getIcSize() {
+        return this.icSize;
+    }
+
     static getExportedTypes() {
         if (TypeRecorder.getInstance()) {
             return TypeRecorder.getInstance().getExportedType();
@@ -449,15 +511,15 @@ export class PandaGen {
         }
     }
 
-    deleteObjProperty(node: ts.Node, obj: VReg, prop: VReg) {
-        this.add(node, deleteObjProperty(obj, prop));
+    deleteObjProperty(node: ts.Node, obj: VReg) {
+        this.add(node, deleteObjProperty(obj));
     }
 
     loadAccumulator(node: ts.Node | NodeKind, vreg: VReg) {
         this.add(node, loadAccumulator(vreg));
     }
 
-    createLexEnv(node: ts.Node, env: VReg, scope: VariableScope | LoopScope) {
+    createLexEnv(node: ts.Node, scope: VariableScope | LoopScope) {
         let numVars = scope.getNumLexEnv();
         let scopeInfoIdx: number | undefined = undefined;
         let lexVarInfo = scope.getLexVarInfo();
@@ -468,7 +530,13 @@ export class PandaGen {
         this.add(
             node,
             newLexicalEnv(numVars, scopeInfoIdx),
-            storeAccumulator(env)
+        )
+    }
+
+    newLexicalEnv(node, numVars: number) {
+        this.add(
+            node,
+            newLexicalEnv(numVars, undefined),
         )
     }
 
@@ -580,7 +648,8 @@ export class PandaGen {
     private loadObjByName(node: ts.Node, obj: VReg, string_id: string) {
         this.add(
             node,
-            loadObjByName(obj, string_id)
+            loadAccumulator(obj),
+            loadObjByName(string_id)
         );
     }
 
@@ -594,7 +663,8 @@ export class PandaGen {
     private loadObjByIndex(node: ts.Node, obj: VReg, index: number) {
         this.add(
             node,
-            loadObjByIndex(obj, index)
+            loadAccumulator(obj),
+            loadObjByIndex(index)
         )
     }
 
@@ -609,7 +679,8 @@ export class PandaGen {
     private loadObjByValue(node: ts.Node, obj: VReg, value: VReg) {
         this.add(
             node,
-            loadObjByValue(obj, value)
+            loadAccumulator(value),
+            loadObjByValue(obj)
         )
     }
 
@@ -750,6 +821,38 @@ export class PandaGen {
         )
     }
 
+    less(node: ts.Node, lhs: VReg) {
+        this.add(node, new Less(new Imm(0), lhs));
+    }
+
+    greater(node: ts.Node, lhs: VReg) {
+        this.add(node, new Greater(new Imm(0), lhs));
+    }
+
+    greaterEq(node: ts.Node, lhs: VReg) {
+        this.add(node, new Greatereq(new Imm(0), lhs));
+    }
+
+    lessEq(node: ts.Node, lhs: VReg) {
+        this.add(node, new Lesseq(new Imm(0), lhs));
+    }
+
+    equal(node: ts.Node, lhs: VReg) {
+        this.add(node, new Eq(new Imm(0), lhs));
+    }
+
+    notEqual(node: ts.Node, lhs: VReg) {
+        this.add(node, new Noteq(new Imm(0), lhs));
+    }
+
+    strictEqual(node: ts.Node, lhs: VReg) {
+        this.add(node, new Stricteq(new Imm(0), lhs));
+    }
+
+    strictNotEqual(node: ts.Node, lhs: VReg) {
+        this.add(node, new Strictnoteq(new Imm(0), lhs));
+    }
+
     /**
      * The method generates code for ther following cases
      *          if (lhs OP acc) {...}
@@ -759,35 +862,35 @@ export class PandaGen {
         // Please keep order of cases the same as in types.ts
         switch (op) {
             case SyntaxKind.LessThanToken: // line 57
-                this.add(node, new EcmaLessdyn(lhs));
+                this.less(node, lhs);
                 this.add(node, new Jeqz(ifFalse));
                 break;
             case SyntaxKind.GreaterThanToken: // line 59
-                this.add(node, new EcmaGreaterdyn(lhs));
+                this.greater(node, lhs);
                 this.add(node, new Jeqz(ifFalse));
                 break;
             case SyntaxKind.LessThanEqualsToken: // line 60
-                this.add(node, new EcmaLesseqdyn(lhs));
+                this.lessEq(node, lhs);
                 this.add(node, new Jeqz(ifFalse));
                 break;
             case SyntaxKind.GreaterThanEqualsToken: // line 61
-                this.add(node, new EcmaGreatereqdyn(lhs));
+                this.greaterEq(node, lhs);
                 this.add(node, new Jeqz(ifFalse));
                 break;
             case SyntaxKind.EqualsEqualsToken: // line 62
-                this.add(node, new EcmaEqdyn(lhs));
+                this.equal(node, lhs);
                 this.add(node, new Jeqz(ifFalse));
                 break;
             case SyntaxKind.ExclamationEqualsToken: // line 63
-                this.add(node, new EcmaNoteqdyn(lhs));
+                this.notEqual(node, lhs);
                 this.add(node, new Jeqz(ifFalse));
                 break;
             case SyntaxKind.EqualsEqualsEqualsToken: // line 64
-                this.add(node, new EcmaStricteqdyn(lhs));
+                this.strictEqual(node, lhs);
                 this.add(node, new Jeqz(ifFalse));
                 break;
             case SyntaxKind.ExclamationEqualsEqualsToken: // line 65
-                this.add(node, new EcmaStrictnoteqdyn(lhs));
+                this.strictNotEqual(node, lhs);
                 this.add(node, new Jeqz(ifFalse));
                 break;
             default:
@@ -798,16 +901,25 @@ export class PandaGen {
     unary(node: ts.Node, op: PrefixUnaryOperator, operand: VReg) {
         switch (op) {
             case SyntaxKind.PlusToken:
-                this.add(node, new EcmaTonumber(operand));
+                this.toNumber(node, operand);
                 break;
             case SyntaxKind.MinusToken:
-                this.add(node, new EcmaNegdyn(operand));
+                this.add(
+                    node,
+                    loadAccumulator(operand),
+                    new Neg(new Imm(0)));
                 break;
             case SyntaxKind.PlusPlusToken:
-                this.add(node, new EcmaIncdyn(operand));
+                this.add(
+                    node,
+                    loadAccumulator(operand),
+                    new Inc(new Imm(0)));
                 break;
             case SyntaxKind.MinusMinusToken:
-                this.add(node, new EcmaDecdyn(operand));
+                this.add(
+                    node,
+                    loadAccumulator(operand),
+                    new Dec(new Imm(0)));
                 break;
             case SyntaxKind.ExclamationToken:
                 let falseLabel = new Label();
@@ -822,7 +934,10 @@ export class PandaGen {
                 this.label(node, endLabel);
                 break;
             case SyntaxKind.TildeToken:
-                this.add(node, new EcmaNotdyn(operand));
+                this.add(
+                    node,
+                    loadAccumulator(operand),
+                    new Not(new Imm(0)));
                 break;
             default:
                 throw new Error("Unimplemented");
@@ -843,61 +958,61 @@ export class PandaGen {
                 break;
             case SyntaxKind.PlusToken: // line 67
             case SyntaxKind.PlusEqualsToken: // line 91
-                this.add(node, new EcmaAdd2dyn(lhs));
+                this.add(node, new Add2(new Imm(0), lhs));
                 break;
             case SyntaxKind.MinusToken: // line 68
             case SyntaxKind.MinusEqualsToken: // line 92
-                this.add(node, new EcmaSub2dyn(lhs));
+                this.add(node, new Sub2(new Imm(0), lhs));
                 break;
             case SyntaxKind.AsteriskToken: // line 69
             case SyntaxKind.AsteriskEqualsToken: // line 93
-                this.add(node, new EcmaMul2dyn(lhs));
+                this.add(node, new Mul2(new Imm(0), lhs));
                 break;
             case SyntaxKind.AsteriskAsteriskToken: // line 70
             case SyntaxKind.AsteriskAsteriskEqualsToken: // line 94
-                this.add(node, new EcmaExpdyn(lhs));
+                this.add(node, new Exp(new Imm(0), lhs));
                 break;
             case SyntaxKind.SlashToken: // line 71
             case SyntaxKind.SlashEqualsToken: // line 95
-                this.add(node, new EcmaDiv2dyn(lhs));
+                this.add(node, new Div2(new Imm(0), lhs));
                 break;
             case SyntaxKind.PercentToken: // line 72
             case SyntaxKind.PercentEqualsToken: // line 96
-                this.add(node, new EcmaMod2dyn(lhs));
+                this.add(node, new Mod2(new Imm(0), lhs));
                 break;
             case SyntaxKind.LessThanLessThanToken: // line 75
             case SyntaxKind.LessThanLessThanEqualsToken: // line 97
-                this.add(node, new EcmaShl2dyn(lhs));
+                this.add(node, new Shl2(new Imm(0), lhs));
                 break;
             case SyntaxKind.GreaterThanGreaterThanToken: // line 76
             case SyntaxKind.GreaterThanGreaterThanEqualsToken: // line 98
-                this.add(node, new EcmaShr2dyn(lhs));
+                this.add(node, new Ashr2(new Imm(0), lhs));
                 break;
             case SyntaxKind.GreaterThanGreaterThanGreaterThanToken: // line 77
             case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken: // line 99
-                this.add(node, new EcmaAshr2dyn(lhs));
+                this.add(node, new Shr2(new Imm(0), lhs));
                 break;
             case SyntaxKind.AmpersandToken: // line 78
             case SyntaxKind.AmpersandEqualsToken: // line 100
-                this.add(node, new EcmaAnd2dyn(lhs));
+                this.add(node, new And2(new Imm(0), lhs));
                 break;
             case SyntaxKind.BarToken: // line 79
             case SyntaxKind.BarEqualsToken: // line 101
-                this.add(node, new EcmaOr2dyn(lhs));
+                this.add(node, new Or2(new Imm(0), lhs));
                 break;
             case SyntaxKind.CaretToken: // line 80
             case SyntaxKind.CaretEqualsToken: // line 102
-                this.add(node, new EcmaXor2dyn(lhs));
+                this.add(node, new Xor2(new Imm(0), lhs));
                 break;
             case SyntaxKind.InKeyword: //line 125
                 // The in operator returns true if the specified property is in the specified object or its prototype chain
-                this.add(node, new EcmaIsindyn(lhs));
+                this.add(node, new Isin(new Imm(0), lhs));
                 break;
             case SyntaxKind.InstanceOfKeyword: //line 126
                 // The instanceof operator tests to see if the prototype property of
                 // a constructor appears anywhere in the prototype chain of an object.
                 // The return value is a boolean value.
-                this.add(node, new EcmaInstanceofdyn(lhs));
+                this.add(node, new Instanceof(new Imm(0), lhs));
                 break;
             default:
                 throw new Error("Unimplemented");
@@ -926,13 +1041,14 @@ export class PandaGen {
     }
 
     return(node: ts.Node | NodeKind) {
-        this.add(node, new ReturnDyn());
+        this.add(node, new Return());
     }
 
     call(node: ts.Node, args: VReg[], passThis: boolean) {
         this.add(
             node,
-            call(args, passThis)
+            loadAccumulator(args[0]), // callee is stored in acc
+            call(args.slice(1), passThis)
         )
     }
 
@@ -950,139 +1066,112 @@ export class PandaGen {
         );
     }
 
-    defineMethod(node: ts.FunctionLikeDeclaration, name: string, objReg: VReg, env: VReg) {
+    defineMethod(node: ts.FunctionLikeDeclaration, name: string, objReg: VReg) {
         let paramLength = getParamLengthOfFunc(node);
         this.add(
             node,
             loadAccumulator(objReg),
-            defineMethod(name, env, paramLength)
+            defineMethod(name, paramLength)
         );
     }
 
-    defineFunction(node: ts.FunctionLikeDeclaration | NodeKind, realNode: ts.FunctionLikeDeclaration, name: string, env: VReg) {
+    defineFunction(node: ts.FunctionLikeDeclaration | NodeKind, realNode: ts.FunctionLikeDeclaration, name: string) {
         let paramLength = getParamLengthOfFunc(realNode);
-        if (realNode.modifiers) {
-            for (let i = 0; i < realNode.modifiers.length; i++) {
-                if (realNode.modifiers[i].kind == ts.SyntaxKind.AsyncKeyword) {
-                    if (realNode.asteriskToken) {
-                        // support async* further
-                        this.add(
-                            node,
-                            defineAsyncGeneratorFunc(name, env, paramLength)
-                        );
-                        return;
-                    } else { // async
-                        this.add(
-                            node,
-                            defineAsyncFunc(name, env, paramLength)
-                        );
-                        return;
-                    }
-                }
-            }
-        }
-
-        if (realNode.asteriskToken) {
-            this.add(
-                node,
-                defineGeneratorFunc(name, env, paramLength)
-            );
-            return;
-        }
-
-        if (ts.isArrowFunction(realNode) || ts.isMethodDeclaration(realNode)) {
-            this.add(
-                node,
-                loadHomeObject(),
-                defineNCFunc(name, env, paramLength)
-            );
-            return;
-        }
-
         this.add(
             node,
-            defineFunc(name, env, paramLength)
+            defineFunc(name, paramLength)
         );
     }
 
     typeOf(node: ts.Node) {
-        this.add(node, new EcmaTypeofdyn());
+        this.add(node, new Typeof(new Imm(0)));
     }
 
     callSpread(node: ts.Node, func: VReg, thisReg: VReg, args: VReg) {
-        this.add(node, new EcmaCallspreaddyn(func, thisReg, args));
+        this.loadAccumulator(node, func);
+        this.add(node, new Apply(new Imm(0), thisReg, args));
     }
 
-    newObjSpread(node: ts.Node, obj: VReg, target: VReg) {
-        this.add(node, new EcmaNewobjspreaddyn(obj, target));
+    newObjSpread(node: ts.Node, obj: VReg) {
+        this.add(node, new Newobjapply(new Imm(0), obj));
     }
 
     getUnmappedArgs(node: ts.Node) {
-        this.add(node, new EcmaGetunmappedargs());
+        this.add(node, new Getunmappedargs());
     }
 
     toNumber(node: ts.Node, arg: VReg) {
-        this.add(node, new EcmaTonumber(arg));
+        this.loadAccumulator(node, arg);
+        this.add(node, new Tonumber(new Imm(0)));
     }
 
     toNumeric(node: ts.Node, arg: VReg) {
-        this.add(node, new EcmaTonumeric(arg));
+        this.loadAccumulator(node, arg);
+        this.add(node, new Tonumeric(new Imm(0)));
     }
 
     createGeneratorObj(node: ts.Node, funcObj: VReg) {
-        this.add(node, new EcmaCreategeneratorobj(funcObj));
+        this.add(node, new Creategeneratorobj(funcObj));
     }
 
     createAsyncGeneratorObj(node: ts.Node, funcObj: VReg) {
-        this.add(node, new EcmaCreateasyncgeneratorobj(funcObj));
+        this.add(node, new Createasyncgeneratorobj(funcObj));
     }
 
-    EcmaCreateiterresultobj(node: ts.Node, value: VReg, done: VReg) {
-        this.add(node, new EcmaCreateiterresultobj(value, done));
+    Createiterresultobj(node: ts.Node, value: VReg, done: VReg) {
+        this.add(node, new Createiterresultobj(value, done));
     }
 
-    EcmaAsyncgeneratorresolve(node: ts.Node | NodeKind, genObj: VReg, value: VReg, done: VReg) {
-        this.add(node, new EcmaAsyncgeneratorresolve(genObj, value, done));
+    Asyncgeneratorresolve(node: ts.Node | NodeKind, genObj: VReg, value: VReg, done: VReg) {
+        this.add(node, new Asyncgeneratorresolve(genObj, value, done));
     }
 
-    EcmaAsyncgeneratorreject(node: ts.Node, genObj: VReg, value: VReg) {
-        this.add(node, new EcmaAsyncgeneratorreject(genObj, value));
+    asyncgeneratorreject(node: ts.Node, genObj: VReg) {
+        this.add(node, new Asyncgeneratorreject(genObj));
     }
 
-    suspendGenerator(node: ts.Node, genObj: VReg, iterRslt: VReg) {
-        this.add(node, new EcmaSuspendgenerator(genObj, iterRslt));
+    suspendGenerator(node: ts.Node, genObj: VReg) {
+        this.add(node, new Suspendgenerator(genObj)); // promise obj is in acc
     }
 
     resumeGenerator(node: ts.Node, genObj: VReg) {
-        this.add(node, new EcmaResumegenerator(genObj));
+        this.add(
+            node,
+            loadAccumulator(genObj),
+            new Resumegenerator());
     }
 
     getResumeMode(node: ts.Node, genObj: VReg) {
-        this.add(node, new EcmaGetresumemode(genObj));
+        this.add(
+            node,
+            loadAccumulator(genObj),
+            new Getresumemode());
     }
 
     asyncFunctionEnter(node: ts.Node | NodeKind) {
-        this.add(node, new EcmaAsyncfunctionenter());
+        this.add(node, new Asyncfunctionenter());
     }
 
-    asyncFunctionAwaitUncaught(node: ts.Node, asynFuncObj: VReg, value: VReg) {
-        this.add(node, new EcmaAsyncfunctionawaituncaught(asynFuncObj, value));
+    asyncFunctionAwaitUncaught(node: ts.Node, asynFuncObj: VReg) {
+        this.add(node, new Asyncfunctionawaituncaught(asynFuncObj)); // received value is in acc
     }
 
-    asyncFunctionResolve(node: ts.Node | NodeKind, asyncObj: VReg, value: VReg, canSuspend: VReg) {
-        this.add(node, new EcmaAsyncfunctionresolve(asyncObj, value, canSuspend));
+    asyncFunctionResolve(node: ts.Node | NodeKind, asyncObj: VReg) {
+        this.add(node, new Asyncfunctionresolve(asyncObj)); // use retVal in acc
     }
 
-    asyncFunctionReject(node: ts.Node | NodeKind, asyncObj: VReg, value: VReg, canSuspend: VReg) {
-        this.add(node, new EcmaAsyncfunctionreject(asyncObj, value, canSuspend));
+    asyncFunctionReject(node: ts.Node | NodeKind, asyncObj: VReg) {
+        this.add(node, new Asyncfunctionreject(asyncObj)); // exception is in acc
     }
 
     getTemplateObject(node: ts.Node | NodeKind, value: VReg) {
-        this.add(node, new EcmaGettemplateobject(value));
+        this.loadAccumulator(node, value);
+        this.add(node, new Gettemplateobject(new Imm(0)));
     }
 
     copyRestArgs(node: ts.Node, index: number) {
-        this.add(node, new EcmaCopyrestargs(new Imm(index)));
+        this.add(node, 
+                 index <= MAX_INT8 ? new Copyrestargs(new Imm(index)) : new WideCopyrestargs(new Imm(index)));
     }
 
     getPropIterator(node: ts.Node) {
@@ -1097,24 +1186,19 @@ export class PandaGen {
         this.add(node, createEmptyObject());
     }
 
-    createObjectHavingMethod(node: ts.Node, idx: number, env: VReg) {
-        this.add(
-            node,
-            loadAccumulator(env),
-            createObjectHavingMethod(idx)
-        );
-    }
-
     createObjectWithBuffer(node: ts.Node, idx: number) {
         this.add(node, createObjectWithBuffer(idx));
     }
 
     setObjectWithProto(node: ts.Node, proto: VReg, object: VReg) {
-        this.add(node, setObjectWithProto(proto, object));
+        this.add(
+            node,
+            loadAccumulator(object),
+            setObjectWithProto(proto));
     }
 
-    copyDataProperties(node: ts.Node, dstObj: VReg, srcObj: VReg) {
-        this.add(node, copyDataProperties(dstObj, srcObj));
+    copyDataProperties(node: ts.Node, dstObj: VReg) {
+        this.add(node, copyDataProperties(dstObj));
     }
 
     defineGetterSetterByValue(node: ts.Node, obj: VReg, name: VReg, getter: VReg, setter: VReg, isComputedPropertyName: boolean) {
@@ -1139,9 +1223,10 @@ export class PandaGen {
     }
 
     storeLexicalVar(node: ts.Node, level: number, slot: number, value: VReg) {
+        this.loadAccumulator(node, value); // value is load to acc
         this.add(
             node,
-            storeLexicalVar(level, slot, value)
+            storeLexicalVar(level, slot)
         );
     }
 
@@ -1152,26 +1237,30 @@ export class PandaGen {
         )
     }
 
-    loadModuleVariable(node: ts.Node, moduleVarName: string, isLocal: boolean) {
-        this.add(node, loadModuleVariable(moduleVarName, isLocal ? 1 : 0));
+    loadModuleVariable(node: ts.Node, index: number, isLocal: boolean) {
+        if (isLocal) {
+            this.add(node, loadLocalModuleVariable(index));
+        } else {
+            this.add(node, loadExternalModuleVariable(index));
+        }
     }
 
-    storeModuleVariable(node: ts.Node | NodeKind, moduleVarName: string) {
-        this.add(node, storeModuleVariable(moduleVarName));
+    storeModuleVariable(node: ts.Node | NodeKind, index: number) {
+        this.add(node, storeModuleVariable(index));
     }
 
-    getModuleNamespace(node: ts.Node, localName: string) {
-        this.add(node, getModuleNamespace(localName));
+    getModuleNamespace(node: ts.Node, moduleRequestIdx: number) {
+        this.add(node, getModuleNamespace(moduleRequestIdx));
     }
 
-    dynamicImportCall(node: ts.Node, moduleSpecifier: VReg) {
-        this.add(node, dynamicImport(moduleSpecifier));
+    dynamicImportCall(node: ts.Node) {
+        this.add(node, dynamicImport());
     }
 
     defineClassWithBuffer(node: ts.Node, name: string, idx: number, parameterLength: number, base: VReg) {
         this.add(
             node,
-            defineClassWithBuffer(name, idx, parameterLength, getVregisterCache(this, CacheList.LexEnv), base)
+            defineClassWithBuffer(name, idx, parameterLength, base)
         )
     }
 
@@ -1196,13 +1285,6 @@ export class PandaGen {
         );
     }
 
-    getIteratorNext(node: ts.Node, iter: VReg, nextMethod: VReg) {
-        this.add(
-            node,
-            getIteratorNext(iter, nextMethod)
-        )
-    }
-
     closeIterator(node: ts.Node, iter: VReg) {
         this.add(
             node,
@@ -1217,10 +1299,18 @@ export class PandaGen {
         );
     }
 
-    superCall(node: ts.Node, num: number, start: VReg) {
+    superCall(node: ts.Node, num: number, args: Array<VReg>) {
+        if (ts.isArrowFunction(jshelpers.getContainingFunction(node))) {
+            this.add(
+                node,
+                superCallInArrow(num, args)
+            )
+            return;
+        }
+
         this.add(
             node,
-            superCall(num, start)
+            superCall(num, args)
         )
     }
 
@@ -1231,7 +1321,8 @@ export class PandaGen {
     ldSuperByName(node: ts.Node, obj: VReg, key: string) {
         this.add(
             node,
-            ldSuperByName(obj, key)
+            loadAccumulator(obj),
+            ldSuperByName(key)
         )
     }
 
@@ -1242,10 +1333,10 @@ export class PandaGen {
         )
     }
 
-    ldSuperByValue(node: ts.Node, obj: VReg, prop: VReg) {
+    ldSuperByValue(node: ts.Node, obj: VReg) {
         this.add(
             node,
-            ldSuperByValue(obj, prop)
+            ldSuperByValue(obj)
         )
     }
 
@@ -1262,14 +1353,12 @@ export class PandaGen {
                 this.ldSuperByName(node, obj, prop);
                 break;
             case "number":
-                let propReg = this.getTemp();
                 this.loadAccumulatorInt(node, prop);
-                this.storeAccumulator(node, propReg);
-                this.ldSuperByValue(node, obj, propReg);
-                this.freeTemps(propReg)
+                this.ldSuperByValue(node, obj);
                 break;
             default:
-                this.ldSuperByValue(node, obj, prop);
+                this.loadAccumulator(node, prop);
+                this.ldSuperByValue(node, obj);
         }
     }
 
@@ -1294,13 +1383,6 @@ export class PandaGen {
         }
     }
 
-    loadHomeObject(node: ts.Node) {
-        this.add(
-            node,
-            loadHomeObject()
-        )
-    }
-
     createRegExpWithLiteral(node: ts.Node, pattern: string, flags: number) {
         this.add(
             node,
@@ -1308,10 +1390,10 @@ export class PandaGen {
         )
     }
 
-    stLetToGlobalRecord(node: ts.Node, string_id: string) {
+    stLetOrClassToGlobalRecord(node: ts.Node, string_id: string) {
         this.add(
             node,
-            stLetToGlobalRecord(string_id));
+            stLetOrClassToGlobalRecord(string_id));
     }
 
     stConstToGlobalRecord(node: ts.Node, string_id: string) {
@@ -1320,12 +1402,6 @@ export class PandaGen {
             stConstToGlobalRecord(string_id));
     }
 
-    stClassToGlobalRecord(node: ts.Node, string_id: string) {
-        this.add(
-            node,
-            stClassToGlobalRecord(string_id));
-    }
-
     loadAccumulatorBigInt(node: ts.Node | NodeKind, str: string) {
         this.add(
             node,
@@ -1337,28 +1413,28 @@ export class PandaGen {
         let endLabel = new Label();
         switch (op) {
             case SyntaxKind.LessThanToken:
-                this.add(node, new EcmaLessdyn(lhs));
+                this.less(node, lhs);
                 break;
             case SyntaxKind.GreaterThanToken:
-                this.add(node, new EcmaGreaterdyn(lhs));
+                this.greater(node, lhs);
                 break;
             case SyntaxKind.LessThanEqualsToken:
-                this.add(node, new EcmaLesseqdyn(lhs));
+                this.lessEq(node, lhs);
                 break;
             case SyntaxKind.GreaterThanEqualsToken:
-                this.add(node, new EcmaGreatereqdyn(lhs));
+                this.greaterEq(node, lhs);
                 break;
             case SyntaxKind.EqualsEqualsToken:
-                this.add(node, new EcmaEqdyn(lhs));
+                this.equal(node, lhs);
                 break;
             case SyntaxKind.ExclamationEqualsToken:
-                this.add(node, new EcmaNoteqdyn(lhs));
+                this.notEqual(node, lhs);
                 break;
             case SyntaxKind.EqualsEqualsEqualsToken:
-                this.add(node, new EcmaStricteqdyn(lhs));
+                this.strictEqual(node, lhs);
                 break;
             case SyntaxKind.ExclamationEqualsEqualsToken:
-                this.add(node, new EcmaStrictnoteqdyn(lhs));
+                this.strictNotEqual(node, lhs);
                 break;
             default:
                 break;
diff --git a/ts2panda/src/pandasm.ts b/ts2panda/src/pandasm.ts
index da58e906a6141e48d42f58ae162b93538929529f..50231d927905c22b73a2721ef576b94bf39280b7 100644
--- a/ts2panda/src/pandasm.ts
+++ b/ts2panda/src/pandasm.ts
@@ -75,6 +75,8 @@ export class Function {
     public ti: Array<number> | undefined;  // typeinfo: record type index array, starts from reg_0
     public es2t: Array<ExportedSymbol2Type> | undefined;  // exportedSymbol2Types
     public ds2t: Array<DeclaredSymbol2Type> | undefined;  // declaredSymbol2Types
+    public kind: number;
+    public icSize: number;
 
     constructor(
         name: string,
@@ -89,7 +91,9 @@ export class Function {
         callType: number | undefined = undefined,
         typeInfo: Array<number> | undefined = undefined,
         exportedSymbol2Types: Array<ExportedSymbol2Type> | undefined = undefined,
-        declaredSymbol2Types: Array<DeclaredSymbol2Type> | undefined = undefined
+        declaredSymbol2Types: Array<DeclaredSymbol2Type> | undefined = undefined,
+        kind: number,
+        icSize: number
     ) {
         this.n = name;
         this.s = signature;
@@ -104,6 +108,8 @@ export class Function {
         this.ti = typeInfo;
         this.es2t = exportedSymbol2Types;
         this.ds2t = declaredSymbol2Types;
+        this.kind = kind;
+        this.icSize = icSize;
     }
 }
 
diff --git a/ts2panda/src/pass/cacheExpander.ts b/ts2panda/src/pass/cacheExpander.ts
index 85dc5bc812eba171ea281a4067873676360cc667..c7844c0811cd95262793f6ba4976b26e586fccd3 100644
--- a/ts2panda/src/pass/cacheExpander.ts
+++ b/ts2panda/src/pass/cacheExpander.ts
@@ -32,6 +32,9 @@ export class CacheExpander implements Pass {
             if (item.isNeeded()) {
                 let expander = item.getExpander();
                 let expansion = expander(pandaGen);
+                if (!expansion) {
+                    continue;
+                }
                 insns.unshift(...expansion);
             }
         }
diff --git a/ts2panda/src/recorder.ts b/ts2panda/src/recorder.ts
index fa4ac237017c534ea18f747bbad0dfa82add4d50..3ac36f04f8f74ea8fc60b079b64a74320f63041d 100644
--- a/ts2panda/src/recorder.ts
+++ b/ts2panda/src/recorder.ts
@@ -571,6 +571,7 @@ export class Recorder {
                 // export default v;
                 // "*default*" is used within this specification as a synthetic name for anonymous default export values.
                 scope.module().addLocalExportEntry(node, "default", "*default*");
+                scope.setDecls(new LetDecl("*default*", node, ModuleVarKind.EXPORTED));
                 break;
             }
             case ts.SyntaxKind.VariableStatement: {
diff --git a/ts2panda/src/regAllocator.ts b/ts2panda/src/regAllocator.ts
index dfcc44b3be0e6f417c3be0cb49fcf5fb2cc0898d..9d5ac4f11ffaf7918829209640bcfdeaf16c6aa5 100644
--- a/ts2panda/src/regAllocator.ts
+++ b/ts2panda/src/regAllocator.ts
@@ -21,7 +21,7 @@ import { DebugInfo } from "./debuginfo";
 import {
     Format,
     IRNode,
-    MovDyn,
+    Mov,
     OperandKind,
     OperandType,
     VReg
@@ -141,19 +141,19 @@ class RegAllocator {
                     } catch {
                         throw Error("no available tmp vReg");
                     }
-                    head.push(new MovDyn(spill, vTmp));
+                    head.push(new Mov(spill, vTmp));
                     operands[j] = vTmp;
                     if (format[j][0] == OperandKind.SrcVReg) {
-                        head.push(new MovDyn(vTmp, vOrigin));
+                        head.push(new Mov(vTmp, vOrigin));
                     } else if (format[j][0] == OperandKind.DstVReg) {
-                        tail.push(new MovDyn(vOrigin, vTmp))
+                        tail.push(new Mov(vOrigin, vTmp))
                     } else if (format[j][0] == OperandKind.SrcDstVReg) {
-                        head.push(new MovDyn(vTmp, vOrigin));
-                        tail.push(new MovDyn(vOrigin, vTmp))
+                        head.push(new Mov(vTmp, vOrigin));
+                        tail.push(new Mov(vOrigin, vTmp))
                     } else {
                         // here we do nothing
                     }
-                    tail.push(new MovDyn(vTmp, spill));
+                    tail.push(new Mov(vTmp, spill));
                 }
             }
         }
@@ -182,7 +182,7 @@ class RegAllocator {
           3. if v.num is bigger than 255, it means all register less than 255 has been already used, they should have been pushed
           into usedVreg
         */
-        if ((<VReg>operands[1]).num >= level) {
+        if ((<VReg>operands[rangeRegOffset]).num >= level) {
             // needs to be adjusted.
             return false;
         }
@@ -224,10 +224,10 @@ class RegAllocator {
             spills.push(spill);
 
             /* We need to make sure that the register input in the .range instruction is continuous(small to big). */
-            head.push(new MovDyn(spill, this.usedVreg[tmp.num + i].vreg));
-            head.push(new MovDyn(this.usedVreg[tmp.num + i].vreg, <VReg>operands[i + rangeRegOffset]));
+            head.push(new Mov(spill, this.usedVreg[tmp.num + i].vreg));
+            head.push(new Mov(this.usedVreg[tmp.num + i].vreg, <VReg>operands[i + rangeRegOffset]));
             operands[i + rangeRegOffset] = this.usedVreg[tmp.num + i].vreg;
-            tail.push(new MovDyn(this.usedVreg[tmp.num + i].vreg, spill));
+            tail.push(new Mov(this.usedVreg[tmp.num + i].vreg, spill));
         }
 
         // for debuginfo
@@ -298,7 +298,7 @@ class RegAllocator {
         for (let i = 0; i < parametersCount; ++i) {
             let v = new VReg();
             this.allocIndexForVreg(v);
-            this.newInsns.unshift(new MovDyn(locals[i], v));
+            this.newInsns.unshift(new Mov(locals[i], v));
         }
 
         pandaGen.setInsns(this.newInsns);
diff --git a/ts2panda/src/statement/classStatement.ts b/ts2panda/src/statement/classStatement.ts
index ace78ccba5dac0c932900b0dabb51245a86a631c..19c2c6f7fc92823a2dae421894e9338e1545ac0e 100644
--- a/ts2panda/src/statement/classStatement.ts
+++ b/ts2panda/src/statement/classStatement.ts
@@ -122,11 +122,11 @@ export function compileClassDeclaration(compiler: Compiler, stmt: ts.ClassLikeDe
     if (hasExportKeywordModifier(stmt)) {
         if (stmt.name) {
             let className = jshelpers.getTextOfIdentifierOrLiteral(stmt.name);
-            let classInfo = classScope.find(className);
-            (<ModuleVariable>classInfo.v).initialize();
-            pandaGen.storeModuleVariable(stmt, className);
+            let v = pandaGen.getScope().findLocal(className);
+            (<ModuleVariable>v).initialize();
+            pandaGen.storeModuleVariable(stmt, (<ModuleVariable>v).getIndex());
         } else if (hasDefaultKeywordModifier(stmt)) {
-            pandaGen.storeModuleVariable(stmt, "*default*");
+            pandaGen.storeModuleVariable(stmt, (<ModuleVariable>pandaGen.getScope().findLocal("*default*")).getIndex());
         } else {
             // throw SyntaxError in Recorder
         }
@@ -134,12 +134,12 @@ export function compileClassDeclaration(compiler: Compiler, stmt: ts.ClassLikeDe
         if (stmt.name) {
             let className = jshelpers.getTextOfIdentifierOrLiteral(stmt.name);
             if (!ts.isClassExpression(stmt) && classScope.getParent() instanceof GlobalScope) {
-                pandaGen.stClassToGlobalRecord(stmt, className);
+                pandaGen.stLetOrClassToGlobalRecord(stmt, className);
             } else {
                 let classInfo = classScope.find(className);
                 (<LocalVariable | ModuleVariable>classInfo.v).initialize();
                 if (classInfo.v instanceof ModuleVariable) {
-                    pandaGen.storeModuleVariable(stmt, className);
+                    pandaGen.storeModuleVariable(stmt, (<ModuleVariable>pandaGen.getScope().findLocal(className)).getIndex());
                 } else {
                     pandaGen.storeAccToLexEnv(stmt, classInfo.scope!, classInfo.level, classInfo.v!, true);
                 }
@@ -396,9 +396,8 @@ export function compileSuperCall(compiler: Compiler, node: ts.CallExpression, ar
         pandaGen.freeTemps(argArray);
     } else {
         let num = args.length;
-        let startReg = num ? args[0] : getVregisterCache(pandaGen, CacheList.undefined);
         loadCtorObj(node, compiler);
-        pandaGen.superCall(node, num, startReg);
+        pandaGen.superCall(node, num, num ? args : [getVregisterCache(pandaGen, CacheList.undefined)]);
     }
 
     let tmpReg = pandaGen.getTemp();
diff --git a/ts2panda/src/statement/forOfStatement.ts b/ts2panda/src/statement/forOfStatement.ts
index 32458918c289e43d3c8301af630f42277196f93e..12bf09e6316ec3ef5fe9b6ed71fb64b20afaba10 100644
--- a/ts2panda/src/statement/forOfStatement.ts
+++ b/ts2panda/src/statement/forOfStatement.ts
@@ -71,7 +71,7 @@ export function compileForOfStatement(stmt: ts.ForOfStatement, compiler: Compile
     let type: IteratorType = IteratorType.Normal;
 
     if (needCreateLoopEnv) {
-        pandaGen.createLexEnv(stmt, loopEnv, loopScope);
+        pandaGen.createLexEnv(stmt, loopScope);
         compiler.pushEnv(loopEnv);
     }
 
diff --git a/ts2panda/src/statement/loopStatement.ts b/ts2panda/src/statement/loopStatement.ts
index 4af9a4a5766df9df14ea1490c8629f7359689ce2..f42f9c4e3855135adfdd7ed74fc3eaf5ff7c8605 100644
--- a/ts2panda/src/statement/loopStatement.ts
+++ b/ts2panda/src/statement/loopStatement.ts
@@ -46,12 +46,10 @@ export function compileDoStatement(stmt: ts.DoStatement, compiler: Compiler) {
     LabelTarget.pushLabelTarget(labelTarget);
     LabelTarget.updateName2LabelTarget(stmt.parent, labelTarget);
 
-    let loopEnv = pandaGen.getTemp();
 
     pandaGen.label(stmt, loopStartLabel);
     if (needCreateLoopEnv) {
-        pandaGen.createLexEnv(stmt, loopEnv, loopScope);
-        compiler.pushEnv(loopEnv);
+        pandaGen.createLexEnv(stmt, loopScope);
     }
 
     compiler.compileStatement(stmt.statement);
@@ -71,7 +69,6 @@ export function compileDoStatement(stmt: ts.DoStatement, compiler: Compiler) {
     }
 
     LabelTarget.popLabelTarget();
-    pandaGen.freeTemps(loopEnv);
     compiler.popScope();
 }
 
@@ -88,12 +85,9 @@ export function compileWhileStatement(stmt: ts.WhileStatement, compiler: Compile
     LabelTarget.pushLabelTarget(labelTarget);
     LabelTarget.updateName2LabelTarget(stmt.parent, labelTarget);
 
-    let loopEnv = pandaGen.getTemp();
-
     pandaGen.label(stmt, loopStartLabel);
     if (needCreateLoopEnv) {
-        pandaGen.createLexEnv(stmt, loopEnv, loopScope);
-        compiler.pushEnv(loopEnv);
+        pandaGen.createLexEnv(stmt, loopScope);
     }
     compiler.compileCondition(stmt.expression, loopEndLabel);
 
@@ -112,7 +106,6 @@ export function compileWhileStatement(stmt: ts.WhileStatement, compiler: Compile
     }
 
     LabelTarget.popLabelTarget();
-    pandaGen.freeTemps(loopEnv);
     compiler.popScope();
 }
 
@@ -123,7 +116,6 @@ export function compileForStatement(stmt: ts.ForStatement, compiler: Compiler) {
     // determine if loopenv need to be created
     let loopScope = <LoopScope>compiler.getRecorder().getScopeOfNode(stmt);
     let needCreateLoopEnv: boolean = loopScope.need2CreateLexEnv();
-    let loopEnv = pandaGen.getTemp();
     let createEnvAtBegining: boolean = false;
     if (needCreateLoopEnv) {
         // determine the location where loopenv should be created
@@ -144,8 +136,7 @@ export function compileForStatement(stmt: ts.ForStatement, compiler: Compiler) {
     LabelTarget.updateName2LabelTarget(stmt.parent, labelTarget);
 
     if (stmt.initializer && ts.isVariableDeclarationList(stmt.initializer) && createEnvAtBegining && needCreateLoopEnv) {
-        pandaGen.createLexEnv(stmt, loopEnv, loopScope);
-        compiler.pushEnv(loopEnv);
+        pandaGen.createLexEnv(stmt, loopScope);
 
         let declList = <ts.VariableDeclarationList>stmt.initializer;
         declList.declarations.forEach(decl => compiler.compileVariableDeclaration(decl));
@@ -180,7 +171,7 @@ export function compileForStatement(stmt: ts.ForStatement, compiler: Compiler) {
 
         // pop the current loopenv and create a new loopenv before the next iteration
         pandaGen.popLexicalEnv(stmt);
-        pandaGen.createLexEnv(stmt, loopEnv, loopScope);
+        pandaGen.createLexEnv(stmt, loopScope);
         variables.forEach((reg, varInfo) => {
             let slot: number = (<Variable>varInfo.v).idxLex;
             // emitStore is not used here to avoid dead-zone check within it, just use storeLexcialVar
@@ -201,8 +192,7 @@ export function compileForStatement(stmt: ts.ForStatement, compiler: Compiler) {
     } else { // compile for in fast mode
         // createLoopEnv if needed
         if (needCreateLoopEnv) {
-            pandaGen.createLexEnv(stmt, loopEnv, loopScope);
-            compiler.pushEnv(loopEnv);
+            pandaGen.createLexEnv(stmt, loopScope);
         }
 
         if (stmt.initializer) {
@@ -245,7 +235,6 @@ export function compileForStatement(stmt: ts.ForStatement, compiler: Compiler) {
     }
 
     LabelTarget.popLabelTarget();
-    pandaGen.freeTemps(loopEnv);
     compiler.popScope();
 }
 
@@ -256,7 +245,6 @@ export function compileForInStatement(stmt: ts.ForInStatement, compiler: Compile
     // determine the location where env should be created
     let loopScope = <LoopScope>compiler.getRecorder().getScopeOfNode(stmt);
     let needCreateLexEnv: boolean = loopScope.need2CreateLexEnv() ? true : false;
-    let loopEnv = pandaGen.getTemp();
 
     // init label info;
     let loopStartLabel = new Label();
@@ -285,8 +273,7 @@ export function compileForInStatement(stmt: ts.ForInStatement, compiler: Compile
 
     pandaGen.label(stmt, loopStartLabel);
     if (needCreateLexEnv) {
-        pandaGen.createLexEnv(stmt, loopEnv, loopScope);
-        compiler.pushEnv(loopEnv);
+        pandaGen.createLexEnv(stmt, loopScope);
     }
 
     // get next prop of enumerator
@@ -311,7 +298,7 @@ export function compileForInStatement(stmt: ts.ForInStatement, compiler: Compile
         compiler.popEnv();
     }
 
-    pandaGen.freeTemps(loopEnv, iterReg, propName);
+    pandaGen.freeTemps(iterReg, propName);
     LabelTarget.popLabelTarget();
     compiler.popScope();
 }
\ No newline at end of file
diff --git a/ts2panda/src/statement/tryStatement.ts b/ts2panda/src/statement/tryStatement.ts
index 05f8e9bea4feb93f15accd90c014cd71ebd8a15b..a8404d1fc2e585378c769480c76b5c3227d468af 100644
--- a/ts2panda/src/statement/tryStatement.ts
+++ b/ts2panda/src/statement/tryStatement.ts
@@ -285,8 +285,7 @@ export class TryBuilderWithForOf extends TryBuilderBase {
 
         pandaGen.label(stmt, this.labelTarget.getContinueTargetLabel()!);
         if (this.hasLoopEnv) {
-            pandaGen.createLexEnv(stmt, <VReg>this.loopEnv, loopScope);
-            compiler.pushEnv(<VReg>this.loopEnv);
+            pandaGen.createLexEnv(stmt, loopScope);
         }
 
         this.compileIteratorNext(stmt, pandaGen, this.iterator, resultReg);
diff --git a/ts2panda/src/ts2panda.ts b/ts2panda/src/ts2panda.ts
index 190871169d9fdc1d8dde509ca1f0a5c30bc3ec73..0d7e1dad1f236506aabfa9469b1a444947106774 100644
--- a/ts2panda/src/ts2panda.ts
+++ b/ts2panda/src/ts2panda.ts
@@ -96,10 +96,28 @@ export class Ts2Panda {
             } else if (isRangeInst(insn)) {
                 // For DynRange insn we only pass the first vreg of continuous vreg array
                 let operands = insn.operands;
-                insImms.push((<Imm>operands[0]).value);
-                insRegs.push((<VReg>operands[1]).num);
-                if (getRangeStartVregPos(insn) == 2) {
-                    insRegs.push((<VReg>operands[2]).num);
+                for (let i = 0; i <= getRangeStartVregPos(insn); i++) {
+                    let operand = operands[i];
+                    if (operand instanceof VReg) {
+                        insRegs.push((<VReg>operand).num);
+                        continue;
+                    }
+
+                    if (operand instanceof Imm) {
+                        insImms.push((<Imm>operand).value);
+                        continue;
+                    }
+
+                    if (typeof (operand) === "string") {
+                        insIds.push(operand);
+                        continue;
+                    }
+
+                    if (operand instanceof Label) {
+                        let labelName = Ts2Panda.labelPrefix + operand.id;
+                        insIds.push(labelName);
+                        continue;
+                    }
                 }
             } else {
                 insn.operands.forEach((operand: OperandType) => {
@@ -230,7 +248,7 @@ export class Ts2Panda {
             }
 
             // get builtin type for tryloadglobal instruction
-            if (inst.kind == IRNodeKind.ECMA_TRYLDGLOBALBYNAME) {
+            if (inst.kind == IRNodeKind.TRYLDGLOBALBYNAME) {
                 let name = inst.operands[0] as string;
                 if (name in BuiltinType) {
                     typeIdx = BuiltinType[name];
@@ -240,7 +258,7 @@ export class Ts2Panda {
             }
 
             // skip arg type
-            if (i < paraCount && inst.kind == IRNodeKind.MOV_DYN) {
+            if (i < paraCount && inst.kind == IRNodeKind.MOV) {
                 let vreg = (inst.operands[0] as VReg).num;
                 let arg = (inst.operands[1] as VReg).num;
                 if (vreg >= paraCount || arg < vregCount) {
@@ -252,7 +270,7 @@ export class Ts2Panda {
             }
 
             // local vreg -> inst
-            if (inst.kind == IRNodeKind.STA_DYN) {
+            if (inst.kind == IRNodeKind.STA) {
                 let vreg = (inst.operands[0] as VReg).num;
                 if (vreg < locals.length && !handledSet.has(vreg)) {
                     typeIdx = locals[vreg].getTypeIndex();
@@ -388,7 +406,9 @@ export class Ts2Panda {
             callType,
             typeInfo,
             exportedSymbol2Types,
-            declaredSymbol2Types
+            declaredSymbol2Types,
+            pg.getFunctionKind(),
+            pg.getIcSize()
         );
 
         LOGD(func);
diff --git a/ts2panda/src/variable.ts b/ts2panda/src/variable.ts
index dce9f8d78c43a9468da919d267396a424921349e..43289eef01df20c6ab68130ba7feda62d777437f 100644
--- a/ts2panda/src/variable.ts
+++ b/ts2panda/src/variable.ts
@@ -133,6 +133,7 @@ export class LocalVariable extends Variable {
 export class ModuleVariable extends Variable {
     private isExport: boolean = false;
     private status: InitStatus | null;
+    private index: number;
 
 
     constructor(declKind: VarDeclarationKind, name: string, status?: InitStatus) {
@@ -158,6 +159,14 @@ export class ModuleVariable extends Variable {
     isExportVar() {
         return this.isExport;
     }
+
+    assignIndex(index: number) {
+        this.index = index;
+    }
+
+    getIndex() {
+        return this.index;
+    }
 }
 
 export class GlobalVariable extends Variable {
diff --git a/ts2panda/templates/irnodes.ts.erb b/ts2panda/templates/irnodes.ts.erb
index 8494ea5569e86eaf2d7daf269eedd8b6004df5c4..54edae0d337c5bc57fc559b56e5ac19fec75cef7 100755
--- a/ts2panda/templates/irnodes.ts.erb
+++ b/ts2panda/templates/irnodes.ts.erb
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import { PandaGen } from "./pandagen"
 % def get_node_kind(mnemonic)
 %   return "#{mnemonic.gsub('.', '_').upcase}"
 % end
@@ -81,7 +82,12 @@
 % end
 %
 % def is_CallRange(insn)
-%   if insn.mnemonic == "call.range" or insn.mnemonic == "calli.dyn.range" or insn.mnemonic == "ecma.callirangedyn" or insn.mnemonic == "ecma.callithisrangedyn" or insn.mnemonic == "ecma.createobjectwithexcludedkeys" or insn.mnemonic == "ecma.newobjdynrange"
+%   if insn.mnemonic == "callrange" or insn.mnemonic == "wide.callrange" or
+%       insn.mnemonic == "callthisrange" or insn.mnemonic == "wide.callthisrange" or
+%       insn.mnemonic == "newobjrange" or insn.mnemonic == "wide.newobjrange" or
+%       insn.mnemonic == "createobjectwithexcludedkeys" or insn.mnemonic == "wide.createobjectwithexcludedkeys" or
+%       insn.mnemonic == "supercallthisrange" or insn.mnemonic == "wide.supercallthisrange" or
+%       insn.mnemonic == "supercallarrowrange" or insn.mnemonic == "wide.supercallarrowrange"
 %      return true
 %   end
 %   return false
@@ -160,13 +166,6 @@
 %   return "[" + operands.join(", ") + "]"
 % end
 %
-% def get_parent_type(insn)
-%  if insn.prefix != nil and insn.prefix.name == "ecma"
-%     return "Intrinsic"
-%  else
-%     return "IRNode"
-%  end
-% end
 // Autogenerated file -- DO NOT EDIT!
 import * as ts from "typescript";
 import {
@@ -287,6 +286,7 @@ export function getInsnFormats(opcode: IRNodeKind) {
 
 export abstract class IRNode {
   private node: ts.Node | NodeKind = NodeKind.Normal;
+  public static pg: PandaGen | undefined = undefined;
   constructor(
     readonly kind: IRNodeKind,
     readonly operands: OperandType[],
@@ -329,18 +329,9 @@ export abstract class IRNode {
   getFormats() {
     return getInsnFormats(this.kind);
   }
-}
-
-export abstract class Intrinsic extends IRNode {
-  constructor(
-    readonly kind: IRNodeKind,
-    readonly operands: OperandType[],
-  ) {
-    super(kind, operands);
-  }
 
-  toString(): string {
-    return super.toString() + " [i]";
+  static setPandagen(pg: PandaGen) {
+    IRNode.pg = pg;
   }
 }
 
@@ -438,8 +429,8 @@ export class DebugInsEndPlaceHolder extends IRNode {
 % result_dst = get_result_dst(insn);
 % is_call_op = is_Call(insn)
 % is_callrange_op = is_CallRange(insn)
-% parent_type = get_parent_type(insn)
-export class <%= insn2node(insn) %> extends <%=parent_type %> {
+% parent_type = "IRNode"
+export class <%= insn2node(insn) %> extends <%= parent_type %> {
 % if is_callrange_op
 %   op_last = ops_list.pop
 %   ops_length = ops_list.size
@@ -455,9 +446,6 @@ export class <%= insn2node(insn) %> extends <%=parent_type %> {
         operands.push(ctor)
       }
     }
-% elsif insn2node(insn) == "BuiltinR2i"
-  constructor(<%= ctor_arg_list[0] %>, <%= ctor_arg_list[1] %>, <%= ctor_arg_list[2] %>[]) {
-    var operands:OperandType[] = [<%=ops_list[0] %>, <%=ops_list[1] %>, ...<%=ops_list[2] %>]
 % else
   constructor(<%= ctor_args %>) {
 % if is_call_op and ops.length() != 0
@@ -474,12 +462,50 @@ export class <%= insn2node(insn) %> extends <%=parent_type %> {
 % end
     super(
       <%= kind %>,
-% if is_call_op or is_callrange_op or insn2node(insn) == "BuiltinR2i"
+% if is_call_op or is_callrange_op
       operands,
 % else
       [<%= ops %>]
 % end
     );
+% is_jit_ic = insn.properties.include?("jit_ic_slot")
+% is_ic = (!is_jit_ic) && insn.properties.include?("ic_slot")
+% if (is_ic)
+%   ret = insn.properties.include?("one_slot") ? 1 : 2;
+    let invalid = 255;
+    let icSize = (<PandaGen>(IRNode.pg)).getIcSize();
+    if (icSize <= invalid) {
+        if ((icSize + <%= ret %>) > 255)  {
+            this.operands[0] = new Imm(256);
+            let inc = <%= ret %> + 256 - icSize;
+            (<PandaGen>(IRNode.pg)).updateIcSize(inc);
+        } else {
+            this.operands[0] = new Imm(icSize);
+            (<PandaGen>(IRNode.pg)).updateIcSize(<%= ret %>);
+        }
+    } else if(icSize > invalid && icSize <= 65535) {
+        this.operands[0] = new Imm(icSize);
+        (<PandaGen>(IRNode.pg)).updateIcSize(<%= ret %>);
+    } else {
+        this.operands[0] = new Imm(invalid);
+    }
+% end
+% if (is_jit_ic && !is_ic)
+%   ret = insn.properties.include?("one_slot") ? 1 : 2;
+    let invalid = 255;
+    let icSize = (<PandaGen>(IRNode.pg)).getIcSize();
+    if (icSize < invalid) {
+        if ((icSize + <%= ret %>) > invalid) {
+            this.operands[0] = new Imm(invalid);
+            (<PandaGen>(IRNode.pg)).updateIcSize((256 - icSize));
+        } else {
+            this.operands[0] = new Imm(icSize);
+            (<PandaGen>(IRNode.pg)).updateIcSize(<%= ret %>);
+        }
+    } else {
+        this.operands[0] = new Imm(invalid);
+    }
+% end
   }
 % if jump
 % target_index = insn.operands.index {|op| op.imm? }
diff --git a/ts2panda/tests/builtIns.test.ts b/ts2panda/tests/builtIns.test.ts
index ace7fc1c21db2e0dc2a952c00e3363df2d1b622a..2ec85828daad71f0df209b090abcc13889319dc0 100644
--- a/ts2panda/tests/builtIns.test.ts
+++ b/ts2panda/tests/builtIns.test.ts
@@ -18,8 +18,8 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaReturnundefined,
-    LdaDyn,
+    Returnundefined,
+    Lda,
     VReg
 } from "../src/irnodes";
 import { checkInstructions, compileMainSnippet, SnippetCompiler } from "./utils/base";
@@ -29,11 +29,11 @@ describe("BuiltInsTest", function () {
     it("Global Value Properties", function () {
         let insns = compileMainSnippet(`NaN; Infinity; globalThis;`);
         let expected = [
-            new LdaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Lda(new VReg()),
+            new Lda(new VReg()),
 
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/commonjs.test.ts b/ts2panda/tests/commonjs.test.ts
index f0148848a4a5ffc5818d88be96e4f84509f2c406..482be37588bdbad98daee9d5a34ec84eeecf646d 100644
--- a/ts2panda/tests/commonjs.test.ts
+++ b/ts2panda/tests/commonjs.test.ts
@@ -19,17 +19,17 @@ import {
 import 'mocha';
 import { checkInstructions, SnippetCompiler } from "./utils/base";
 import {
-    EcmaCallarg1dyn,
-    EcmaCallirangedyn,
-    EcmaDefinefuncdyn,
-    EcmaReturnundefined,
-    EcmaStobjbyname,
+    Callarg1,
+    Callrange,
+    Definefunc,
+    Returnundefined,
+    Stobjbyname,
     Imm,
-    LdaDyn,
-    LdaiDyn,
+    Lda,
+    Ldai,
     LdaStr,
-    MovDyn,
-    StaDyn,
+    Mov,
+    Sta,
     VReg
 } from "../src/irnodes";
 import { CmdOptions } from '../src/cmdOptions';
@@ -44,20 +44,21 @@ describe("CommonJsTest", function () {
         CmdOptions.isCommonJs = () => {return false};
         let funcMainInsns = snippetCompiler.getGlobalInsns();
         let expected = [
-            new EcmaDefinefuncdyn('#1#', new Imm(5), new VReg()),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaCallirangedyn(new Imm(5), [new VReg(), new VReg(), new VReg(), new VReg(), new VReg(), new VReg()]),
-            new EcmaReturnundefined(),
+            new Definefunc(new Imm(0), '#1#', new Imm(5)),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Callrange(new Imm(1), new Imm(4), [new VReg(), new VReg(), new VReg(), new VReg(), new VReg()]),
+            new Returnundefined(),
         ];
         expect(checkInstructions(funcMainInsns, expected)).to.be.true;
     });
@@ -72,13 +73,14 @@ describe("CommonJsTest", function () {
         let requireReg = new VReg();
         let moduleRequest = new VReg();
         let expected = [
-            new LdaDyn(requirePara),
-            new StaDyn(requireReg),
+            new Lda(requirePara),
+            new Sta(requireReg),
             new LdaStr("a.js"),
-            new StaDyn(moduleRequest),
-            new EcmaCallarg1dyn(requireReg, moduleRequest),
-            new StaDyn(new VReg()),
-            new EcmaReturnundefined()
+            new Sta(moduleRequest),
+            new Lda(new VReg()),
+            new Callarg1(new Imm(0), moduleRequest),
+            new Sta(new VReg()),
+            new Returnundefined()
         ];
         expect(checkInstructions(execInsns, expected)).to.be.true;
     });
@@ -94,14 +96,14 @@ describe("CommonJsTest", function () {
         let tmpReg = new VReg();
         let a = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(1)),
-            new StaDyn(a),
-            new LdaDyn(exportsPara),
-            new StaDyn(exportsReg),
-            new MovDyn(tmpReg, exportsReg),
-            new LdaDyn(a),
-            new EcmaStobjbyname("a", tmpReg),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(1)),
+            new Sta(a),
+            new Lda(exportsPara),
+            new Sta(exportsReg),
+            new Mov(tmpReg, exportsReg),
+            new Lda(a),
+            new Stobjbyname(new Imm(0), "a", tmpReg),
+            new Returnundefined()
         ];
         expect(checkInstructions(execInsns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/esmodule.test.ts b/ts2panda/tests/esmodule.test.ts
index e28b9b6db430b7b7535d080121fb5d35d76fe466..e9fe576b480c5040bf37428551f6ead9f1fd056f 100644
--- a/ts2panda/tests/esmodule.test.ts
+++ b/ts2panda/tests/esmodule.test.ts
@@ -19,16 +19,16 @@ import {
 import 'mocha';
 import { checkInstructions, SnippetCompiler } from "./utils/base";
 import {
-    EcmaDefineclasswithbuffer,
-    EcmaLdmodulevar,
-    EcmaReturnundefined,
-    EcmaStmodulevar,
-    EcmaThrowundefinedifhole,
+    Defineclasswithbuffer,
+    Ldlocalmodulevar,
+    Returnundefined,
+    Stmodulevar,
+    ThrowUndefinedifhole,
     Imm,
-    LdaDyn,
+    Lda,
     LdaStr,
-    MovDyn,
-    StaDyn,
+    Mov,
+    Sta,
     VReg
 } from "../src/irnodes";
 import { CmdOptions } from '../src/cmdOptions';
@@ -44,12 +44,12 @@ describe("ExportDeclaration", function () {
         let funcMainInsns = snippetCompiler.getGlobalInsns();
         let classReg = new VReg();
         let expected = [
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaDefineclasswithbuffer("#1#C", new Imm(0), new Imm(0), new VReg(), new VReg()),
-            new StaDyn(classReg),
-            new LdaDyn(classReg),
-            new EcmaStmodulevar('C'),
-            new EcmaReturnundefined(),
+            new Mov(new VReg(), new VReg()),
+            new Defineclasswithbuffer(new Imm(0), "#1#C", "0", new Imm(0), new VReg()),
+            new Sta(classReg),
+            new Lda(classReg),
+            new Stmodulevar(new Imm(0)),
+            new Returnundefined(),
         ];
         expect(checkInstructions(funcMainInsns, expected)).to.be.true;
     });
@@ -64,14 +64,14 @@ describe("ExportDeclaration", function () {
         let v = new VReg();
         let name = new VReg();
         let expected = [
-            new EcmaLdmodulevar("a", new Imm(0)),
-            new StaDyn(a),
+            new Ldlocalmodulevar(new Imm(0)),
+            new Sta(a),
             new LdaStr("a"),
-            new StaDyn(name),
-            new EcmaThrowundefinedifhole(a, name),
-            new LdaDyn(a),
-            new StaDyn(v),
-            new EcmaReturnundefined(),
+            new Sta(name),
+            new ThrowUndefinedifhole(a, name),
+            new Lda(a),
+            new Sta(v),
+            new Returnundefined(),
         ];
         expect(checkInstructions(funcMainInsns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/expression/arguments.test.ts b/ts2panda/tests/expression/arguments.test.ts
index 3dd2fbd706b16156e10009d51262ed3e4564493e..44e9dc2a3b6b286e2f10e8672e5399575dfb8a42 100644
--- a/ts2panda/tests/expression/arguments.test.ts
+++ b/ts2panda/tests/expression/arguments.test.ts
@@ -18,13 +18,12 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaGetunmappedargs,
-    EcmaLdobjbyindex,
-    EcmaReturnundefined,
+    Getunmappedargs,
+    Ldobjbyindex,
+    Returnundefined,
     Imm,
-    LdaDyn,
-    ResultType,
-    StaDyn,
+    Lda,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, SnippetCompiler } from "../utils/base";
@@ -36,12 +35,13 @@ describe("arguments Keyword", function () {
         let argumentsReg = new VReg();
         let temp1 = new VReg();
         let expected = [
-            new EcmaGetunmappedargs(),
-            new StaDyn(argumentsReg),
-            new LdaDyn(argumentsReg),
-            new StaDyn(temp1),
-            new EcmaLdobjbyindex(temp1, new Imm(0)),
-            new EcmaReturnundefined()
+            new Getunmappedargs(),
+            new Sta(argumentsReg),
+            new Lda(argumentsReg),
+            new Sta(temp1),
+            new Lda(temp1),
+            new Ldobjbyindex(new Imm(0), new Imm(0)),
+            new Returnundefined()
         ];
         let functionPg = snippetCompiler.getPandaGenByName("foo");
         let insns = functionPg!.getInsns();
@@ -55,12 +55,13 @@ describe("arguments Keyword", function () {
         let parameterArguments = new VReg();
         let temp1 = new VReg();
         let expected = [
-            new EcmaGetunmappedargs(),
-            new StaDyn(new VReg()),
-            new LdaDyn(parameterArguments),
-            new StaDyn(temp1),
-            new EcmaLdobjbyindex(temp1, new Imm(0)),
-            new EcmaReturnundefined()
+            new Getunmappedargs(),
+            new Sta(new VReg()),
+            new Lda(parameterArguments),
+            new Sta(temp1),
+            new Lda(temp1),
+            new Ldobjbyindex(new Imm(0), new Imm(0)),
+            new Returnundefined()
         ];
         let functionPg = snippetCompiler.getPandaGenByName("foo");
         let insns = functionPg!.getInsns();
diff --git a/ts2panda/tests/expression/binary.test.ts b/ts2panda/tests/expression/binary.test.ts
index c1765ac4251b2e6a1a374115f03796a78e7c32f1..a6fb452a26b51ab50743b436d7661d4b66c2699f 100644
--- a/ts2panda/tests/expression/binary.test.ts
+++ b/ts2panda/tests/expression/binary.test.ts
@@ -18,36 +18,35 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaAdd2dyn,
-    EcmaAnd2dyn,
-    EcmaAshr2dyn,
-    EcmaCreateemptyobject,
-    EcmaDiv2dyn,
-    EcmaExpdyn,
-    EcmaMod2dyn,
-    EcmaMul2dyn,
-    EcmaOr2dyn,
-    EcmaReturnundefined,
-    EcmaShl2dyn,
-    EcmaShr2dyn,
-    EcmaStglobalvar,
-    EcmaStlettoglobalrecord,
-    EcmaStobjbyname,
-    EcmaStrictnoteqdyn,
-    EcmaSub2dyn,
-    EcmaTryldglobalbyname,
-    EcmaTrystglobalbyname,
-    EcmaXor2dyn,
+    Add2,
+    And2,
+    Ashr2,
+    Createemptyobject,
+    Div2,
+    Exp,
+    Mod2,
+    Mul2,
+    Or2,
+    Returnundefined,
+    Shl2,
+    Shr2,
+    Stglobalvar,
+    Sttoglobalrecord,
+    Stobjbyname,
+    Strictnoteq,
+    Sub2,
+    Tryldglobalbyname,
+    Trystglobalbyname,
+    Xor2,
     Imm,
     Jeqz,
     Jmp,
     Label,
-    LdaDyn,
-    LdaiDyn,
+    Lda,
+    Ldai,
     LdaStr,
-    MovDyn,
-    ResultType,
-    StaDyn,
+    Mov,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
@@ -57,11 +56,11 @@ describe("BinaryOperationsTest", function () {
         let insns = compileMainSnippet("2 + 3");
         let lhs = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(2)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(3)),
-            new EcmaAdd2dyn(lhs),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(2)),
+            new Sta(lhs),
+            new Ldai(new Imm(3)),
+            new Add2(new Imm(0), lhs),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -70,11 +69,11 @@ describe("BinaryOperationsTest", function () {
         let insns = compileMainSnippet("5 - 1");
         let lhs = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(1)),
-            new EcmaSub2dyn(lhs),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sta(lhs),
+            new Ldai(new Imm(1)),
+            new Sub2(new Imm(0), lhs),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -85,19 +84,19 @@ describe("BinaryOperationsTest", function () {
         let leftNullishLabel = new Label();
         let endLabel = new Label();
         let expected = [
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaStrictnoteqdyn(new VReg()),
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Strictnoteq(new Imm(0), new VReg()),
             new Jeqz(leftNullishLabel),
-            new LdaDyn(new VReg()),
-            new EcmaStrictnoteqdyn(new VReg()),
+            new Lda(new VReg()),
+            new Strictnoteq(new Imm(1), new VReg()),
             new Jeqz(leftNullishLabel),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(endLabel),
             leftNullishLabel,
-            new LdaiDyn(new Imm(1)),
+            new Ldai(new Imm(1)),
             endLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -113,21 +112,21 @@ describe("BinaryOperationsTest", function () {
         let leftNullishLabel = new Label();
         let endLabel = new Label();
         let expected = [
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaStrictnoteqdyn(new VReg()),
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Strictnoteq(new Imm(0), new VReg()),
             new Jeqz(leftNullishLabel),
-            new LdaDyn(new VReg()),
-            new EcmaStrictnoteqdyn(new VReg()),
+            new Lda(new VReg()),
+            new Strictnoteq(new Imm(1), new VReg()),
             new Jeqz(leftNullishLabel),
 
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(endLabel),
 
             leftNullishLabel,
-            new LdaiDyn(new Imm(1)),
+            new Ldai(new Imm(1)),
             endLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
 
@@ -143,21 +142,21 @@ describe("BinaryOperationsTest", function () {
         let leftNullishLabel = new Label();
         let endLabel = new Label();
         let expected = [
-            new LdaiDyn(new Imm(2)),
-            new StaDyn(new VReg()),
-            new EcmaStrictnoteqdyn(new VReg()),
+            new Ldai(new Imm(2)),
+            new Sta(new VReg()),
+            new Strictnoteq(new Imm(0), new VReg()),
             new Jeqz(leftNullishLabel),
-            new LdaDyn(new VReg()),
-            new EcmaStrictnoteqdyn(new VReg()),
+            new Lda(new VReg()),
+            new Strictnoteq(new Imm(1), new VReg()),
             new Jeqz(leftNullishLabel),
 
-            new LdaDyn(lhs),
+            new Lda(lhs),
             new Jmp(endLabel),
 
             leftNullishLabel,
-            new LdaiDyn(new Imm(1)),
+            new Ldai(new Imm(1)),
             endLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
 
@@ -170,11 +169,11 @@ describe("BinaryOperationsTest", function () {
         let insns = compileMainSnippet("3 * 4");
         let lhs = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(3)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(4)),
-            new EcmaMul2dyn(lhs),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(3)),
+            new Sta(lhs),
+            new Ldai(new Imm(4)),
+            new Mul2(new Imm(0), lhs),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -183,11 +182,11 @@ describe("BinaryOperationsTest", function () {
         let insns = compileMainSnippet("2 ** 3");
         let lhs = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(2)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(3)),
-            new EcmaExpdyn(lhs),
-            new EcmaReturnundefined(),
+            new Ldai(new Imm(2)),
+            new Sta(lhs),
+            new Ldai(new Imm(3)),
+            new Exp(new Imm(0), lhs),
+            new Returnundefined(),
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -196,11 +195,11 @@ describe("BinaryOperationsTest", function () {
         let insns = compileMainSnippet("7 / 1");
         let lhs = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(7)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(1)),
-            new EcmaDiv2dyn(lhs),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(7)),
+            new Sta(lhs),
+            new Ldai(new Imm(1)),
+            new Div2(new Imm(0), lhs),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -209,11 +208,11 @@ describe("BinaryOperationsTest", function () {
         let insns = compileMainSnippet("8 % 2");
         let lhs = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(8)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(2)),
-            new EcmaMod2dyn(lhs),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(8)),
+            new Sta(lhs),
+            new Ldai(new Imm(2)),
+            new Mod2(new Imm(0), lhs),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -222,11 +221,11 @@ describe("BinaryOperationsTest", function () {
         let insns = compileMainSnippet("2 << 3");
         let lhs = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(2)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(3)),
-            new EcmaShl2dyn(lhs),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(2)),
+            new Sta(lhs),
+            new Ldai(new Imm(3)),
+            new Shl2(new Imm(0), lhs),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -235,11 +234,11 @@ describe("BinaryOperationsTest", function () {
         let insns = compileMainSnippet("4 >> 1");
         let lhs = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(4)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(1)),
-            new EcmaShr2dyn(lhs),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(4)),
+            new Sta(lhs),
+            new Ldai(new Imm(1)),
+            new Shr2(new Imm(0), lhs),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -248,11 +247,11 @@ describe("BinaryOperationsTest", function () {
         let insns = compileMainSnippet("12 >>> 2");
         let lhs = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(12)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(2)),
-            new EcmaAshr2dyn(lhs),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(12)),
+            new Sta(lhs),
+            new Ldai(new Imm(2)),
+            new Ashr2(new Imm(0), lhs),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -261,11 +260,11 @@ describe("BinaryOperationsTest", function () {
         let insns = compileMainSnippet("3 & 4");
         let lhs = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(3)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(4)),
-            new EcmaAnd2dyn(lhs),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(3)),
+            new Sta(lhs),
+            new Ldai(new Imm(4)),
+            new And2(new Imm(0), lhs),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -274,11 +273,11 @@ describe("BinaryOperationsTest", function () {
         let insns = compileMainSnippet("2 | 5");
         let lhs = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(2)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(5)),
-            new EcmaOr2dyn(lhs),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(2)),
+            new Sta(lhs),
+            new Ldai(new Imm(5)),
+            new Or2(new Imm(0), lhs),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -287,11 +286,11 @@ describe("BinaryOperationsTest", function () {
         let insns = compileMainSnippet("7 ^ 3");
         let lhs = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(7)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(3)),
-            new EcmaXor2dyn(lhs),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(7)),
+            new Sta(lhs),
+            new Ldai(new Imm(3)),
+            new Xor2(new Imm(0), lhs),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -299,11 +298,11 @@ describe("BinaryOperationsTest", function () {
     it("let i; i = 2", function () {
         let insns = compileMainSnippet("let i; i = 2;");
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaStlettoglobalrecord('i'),
-            new LdaiDyn(new Imm(2)),
-            new EcmaTrystglobalbyname('i'),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Sttoglobalrecord(new Imm(0), 'i'),
+            new Ldai(new Imm(2)),
+            new Trystglobalbyname(new Imm(1), 'i'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -315,9 +314,9 @@ describe("BinaryOperationsTest", function () {
                                         `);
         let expected = [
             new LdaStr("use strict"),
-            new LdaiDyn(new Imm(1)),
-            new EcmaTrystglobalbyname("a"),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(1)),
+            new Trystglobalbyname(new Imm(0), "a"),
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -327,9 +326,9 @@ describe("BinaryOperationsTest", function () {
         let insns = compileMainSnippet("((x)) = 1;");
 
         let expected = [
-            new LdaiDyn(new Imm(1)),
-            new EcmaStglobalvar("x"),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(1)),
+            new Stglobalvar(new Imm(0), "x"),
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -342,17 +341,17 @@ describe("BinaryOperationsTest", function () {
         let tempObj = new VReg();
 
         let expected = [
-            new EcmaCreateemptyobject(),
-            new StaDyn(new VReg()),
+            new Createemptyobject(),
+            new Sta(new VReg()),
             // insns for `((a.b)) = 1`
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(tempObj),
-            new MovDyn(objReg, tempObj),
-            new LdaiDyn(new Imm(1)),
-
-            new EcmaStobjbyname("b", objReg),
-            new EcmaReturnundefined()
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(tempObj),
+            new Mov(objReg, tempObj),
+            new Ldai(new Imm(1)),
+
+            new Stobjbyname(new Imm(2), "b", objReg),
+            new Returnundefined()
         ]
         expect(checkInstructions(insns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/expression/call.test.ts b/ts2panda/tests/expression/call.test.ts
index 29207a2d371329bafe6f59e2b97f0429e4f38123..796575761a7870aae6e5a8ff2220f45eb7aae140 100644
--- a/ts2panda/tests/expression/call.test.ts
+++ b/ts2panda/tests/expression/call.test.ts
@@ -18,27 +18,27 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaCallarg0dyn,
-    EcmaCallarg1dyn,
-    EcmaCallithisrangedyn,
-    EcmaCallspreaddyn,
-    EcmaCreatearraywithbuffer,
-    EcmaCreateemptyarray,
-    EcmaDynamicimport,
-    EcmaLdobjbyname,
-    EcmaLdobjbyvalue,
-    EcmaReturnundefined,
-    EcmaStarrayspread,
-    EcmaStconsttoglobalrecord,
-    EcmaStlettoglobalrecord,
-    EcmaTryldglobalbyname,
+    Dynamicimport,
+    Callarg0,
+    Callarg1,
+    Callthisrange,
+    Apply,
+    Createarraywithbuffer,
+    Createemptyarray,
+    Ldobjbyname,
+    Ldobjbyvalue,
+    Returnundefined,
+    Starrayspread,
+    Stconsttoglobalrecord,
+    Sttoglobalrecord,
+    Tryldglobalbyname,
     Imm,
-    LdaDyn,
-    LdaiDyn,
-    LdaStr,
-    ResultType,
-    StaDyn,
-    VReg
+    Lda,
+    Ldai,
+    Sta,
+    VReg,
+    Callthis0,
+    LdaStr
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
 
@@ -49,11 +49,12 @@ describe("CallTest", function () {
       `);
         let arg0 = new VReg();
         let expected = [
-            new EcmaTryldglobalbyname("foo"),
-            new StaDyn(arg0),
-            new EcmaCallarg0dyn(arg0),
+            new Tryldglobalbyname(new Imm(0), "foo"),
+            new Sta(arg0),
+            new Lda(arg0),
+            new Callarg0(new Imm(1)),
 
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -66,14 +67,15 @@ describe("CallTest", function () {
         let arg0 = new VReg();
         let arg2 = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('i'),
-            new EcmaTryldglobalbyname("foo"),
-            new StaDyn(arg0),
-            new EcmaTryldglobalbyname('i'),
-            new StaDyn(arg2),
-            new EcmaCallarg1dyn(arg0, arg2),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'i'),
+            new Tryldglobalbyname(new Imm(1), "foo"),
+            new Sta(arg0),
+            new Tryldglobalbyname(new Imm(2), 'i'),
+            new Sta(arg2),
+            new Lda(arg0),
+            new Callarg1(new Imm(3), arg2),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -86,13 +88,15 @@ describe("CallTest", function () {
         let arg0 = new VReg();
         let arg1 = new VReg();
         let expected = [
-            new EcmaTryldglobalbyname("Foo"),
-            new StaDyn(arg0),
-            new EcmaLdobjbyname("method", arg0),
-            new StaDyn(arg1),
-            new EcmaCallithisrangedyn(new Imm(1), [arg1, obj]),
+            new Tryldglobalbyname(new Imm(0), "Foo"),
+            new Sta(arg0),
+            new Lda(arg0),
+            new Ldobjbyname(new Imm(1), "method"),
+            new Sta(arg1),
+            new Lda(arg0),
+            new Callthis0(new Imm(3), obj),
 
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -108,25 +112,26 @@ describe("CallTest", function () {
         let arrayInstance = new VReg();
 
         let expected = [
-            new EcmaCreatearraywithbuffer(new Imm(0)),
-            new StaDyn(arrayInstance),
-            new LdaDyn(arrayInstance),
-            new EcmaStconsttoglobalrecord('args'),
+            new Createarraywithbuffer(new Imm(0), "0"),
+            new Sta(arrayInstance),
+            new Lda(arrayInstance),
+            new Stconsttoglobalrecord(new Imm(1), 'args'),
 
-            new EcmaTryldglobalbyname("myFunction"),
-            new StaDyn(arg0),
+            new Tryldglobalbyname(new Imm(2), "myFunction"),
+            new Sta(arg0),
 
-            new EcmaCreateemptyarray(),
-            new StaDyn(arrayInstance),
-            new LdaiDyn(new Imm(0)),
-            new StaDyn(lengthReg),
-            new EcmaTryldglobalbyname('args'),
-            new EcmaStarrayspread(arrayInstance, lengthReg),
-            new StaDyn(lengthReg),
-            new LdaDyn(arrayInstance),
+            new Createemptyarray(new Imm(3), ),
+            new Sta(arrayInstance),
+            new Ldai(new Imm(0)),
+            new Sta(lengthReg),
+            new Tryldglobalbyname(new Imm(4), 'args'),
+            new Starrayspread(arrayInstance, lengthReg),
+            new Sta(lengthReg),
+            new Lda(arrayInstance),
 
-            new EcmaCallspreaddyn(arg0, globalEnv, arrayInstance),
-            new EcmaReturnundefined()
+            new Lda(arg0),
+            new Apply(new Imm(5), globalEnv, arrayInstance),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -140,15 +145,16 @@ describe("CallTest", function () {
         let arg0 = new VReg();
         let arg1 = new VReg();
         let expected = [
-            new EcmaTryldglobalbyname("Foo"),
-            new StaDyn(arg0),
-            new EcmaTryldglobalbyname("method"),
-            new StaDyn(prop),
-            new EcmaLdobjbyvalue(arg0, prop),
-            new StaDyn(arg1),
-            new EcmaCallithisrangedyn(new Imm(1), [arg1, obj]),
+            new Tryldglobalbyname(new Imm(0), "Foo"),
+            new Sta(arg0),
+            new Tryldglobalbyname(new Imm(1), "method"),
+            new Sta(prop),
+            new Lda(prop),
+            new Ldobjbyvalue(new Imm(2), arg0),
+            new Sta(arg1),
+            new Callthisrange(new Imm(4), new Imm(1), [arg1, obj]),
 
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -158,9 +164,8 @@ describe("CallTest", function () {
         let specifier = new VReg();
         let expected = [
             new LdaStr("./test.js"),
-            new StaDyn(specifier),
-            new EcmaDynamicimport(specifier),
-            new EcmaReturnundefined()
+            new Dynamicimport(specifier),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     })
diff --git a/ts2panda/tests/expression/cmpBinary.test.ts b/ts2panda/tests/expression/cmpBinary.test.ts
index 9d9c6dd63575ea48064238fea5bdf9c58eae26dc..ef4731c85d3096446fde45241ae418065d312c0e 100644
--- a/ts2panda/tests/expression/cmpBinary.test.ts
+++ b/ts2panda/tests/expression/cmpBinary.test.ts
@@ -18,34 +18,33 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaAnd2dyn,
-    EcmaEqdyn,
-    EcmaGreaterdyn,
-    EcmaGreatereqdyn,
-    EcmaIncdyn,
-    EcmaInstanceofdyn,
-    EcmaIsindyn,
-    EcmaLessdyn,
-    EcmaLesseqdyn,
-    EcmaNoteqdyn,
-    EcmaOr2dyn,
-    EcmaReturnundefined,
-    EcmaStlettoglobalrecord,
-    EcmaStricteqdyn,
-    EcmaStrictnoteqdyn,
-    EcmaTonumeric,
-    EcmaTryldglobalbyname,
-    EcmaTrystglobalbyname,
-    EcmaXor2dyn,
+    And2,
+    Eq,
+    Greater,
+    Greatereq,
+    Inc,
+    Instanceof,
+    Isin,
+    Less,
+    Lesseq,
+    Noteq,
+    Or2,
+    Returnundefined,
+    Sttoglobalrecord,
+    Stricteq,
+    Strictnoteq,
+    Tonumeric,
+    Tryldglobalbyname,
+    Trystglobalbyname,
+    Xor2,
     Imm,
     Jeqz,
     Jmp,
     Label,
-    LdaDyn,
-    LdaiDyn,
+    Lda,
+    Ldai,
     LdaStr,
-    ResultType,
-    StaDyn,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
@@ -58,17 +57,17 @@ describe("CmpBinaryOperators", function () {
         let endLabel = new Label();
 
         let expected = [
-            new LdaiDyn(new Imm(2)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(3)),
-            new EcmaLessdyn(lhs),
+            new Ldai(new Imm(2)),
+            new Sta(lhs),
+            new Ldai(new Imm(3)),
+            new Less(new Imm(0), lhs),
             new Jeqz(falseLabel),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(endLabel),
             falseLabel,
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             endLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -80,17 +79,17 @@ describe("CmpBinaryOperators", function () {
         let endLabel = new Label();
 
         let expected = [
-            new LdaiDyn(new Imm(3)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(1)),
-            new EcmaGreaterdyn(lhs),
+            new Ldai(new Imm(3)),
+            new Sta(lhs),
+            new Ldai(new Imm(1)),
+            new Greater(new Imm(0), lhs),
             new Jeqz(falseLabel),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(endLabel),
             falseLabel,
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             endLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -102,17 +101,17 @@ describe("CmpBinaryOperators", function () {
         let endLabel = new Label();
 
         let expected = [
-            new LdaiDyn(new Imm(3)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(4)),
-            new EcmaLesseqdyn(lhs),
+            new Ldai(new Imm(3)),
+            new Sta(lhs),
+            new Ldai(new Imm(4)),
+            new Lesseq(new Imm(0), lhs),
             new Jeqz(falseLabel),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(endLabel),
             falseLabel,
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             endLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -124,17 +123,17 @@ describe("CmpBinaryOperators", function () {
         let endLabel = new Label();
 
         let expected = [
-            new LdaiDyn(new Imm(3)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(2)),
-            new EcmaGreatereqdyn(lhs),
+            new Ldai(new Imm(3)),
+            new Sta(lhs),
+            new Ldai(new Imm(2)),
+            new Greatereq(new Imm(0), lhs),
             new Jeqz(falseLabel),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(endLabel),
             falseLabel,
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             endLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -146,17 +145,17 @@ describe("CmpBinaryOperators", function () {
         let endLabel = new Label();
 
         let expected = [
-            new LdaiDyn(new Imm(3)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(3)),
-            new EcmaEqdyn(lhs),
+            new Ldai(new Imm(3)),
+            new Sta(lhs),
+            new Ldai(new Imm(3)),
+            new Eq(new Imm(0), lhs),
             new Jeqz(falseLabel),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(endLabel),
             falseLabel,
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             endLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -168,17 +167,17 @@ describe("CmpBinaryOperators", function () {
         let endLabel = new Label();
 
         let expected = [
-            new LdaiDyn(new Imm(3)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(2)),
-            new EcmaNoteqdyn(lhs),
+            new Ldai(new Imm(3)),
+            new Sta(lhs),
+            new Ldai(new Imm(2)),
+            new Noteq(new Imm(0), lhs),
             new Jeqz(falseLabel),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(endLabel),
             falseLabel,
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             endLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -190,17 +189,17 @@ describe("CmpBinaryOperators", function () {
         let endLabel = new Label();
 
         let expected = [
-            new LdaiDyn(new Imm(3)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(3)),
-            new EcmaStricteqdyn(lhs),
+            new Ldai(new Imm(3)),
+            new Sta(lhs),
+            new Ldai(new Imm(3)),
+            new Stricteq(new Imm(0), lhs),
             new Jeqz(falseLabel),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(endLabel),
             falseLabel,
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             endLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -212,17 +211,17 @@ describe("CmpBinaryOperators", function () {
         let endLabel = new Label();
 
         let expected = [
-            new LdaiDyn(new Imm(3)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(3)),
-            new EcmaStrictnoteqdyn(lhs),
+            new Ldai(new Imm(3)),
+            new Sta(lhs),
+            new Ldai(new Imm(3)),
+            new Strictnoteq(new Imm(0), lhs),
             new Jeqz(falseLabel),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(endLabel),
             falseLabel,
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             endLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -233,14 +232,14 @@ describe("CmpBinaryOperators", function () {
         let lhs = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(3)),
-            new EcmaAnd2dyn(lhs),
-            new EcmaTrystglobalbyname('a'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(3)),
+            new And2(new Imm(2), lhs),
+            new Trystglobalbyname(new Imm(3), 'a'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -251,14 +250,14 @@ describe("CmpBinaryOperators", function () {
         let lhs = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(3)),
-            new EcmaOr2dyn(lhs),
-            new EcmaTrystglobalbyname('a'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(3)),
+            new Or2(new Imm(2), lhs),
+            new Trystglobalbyname(new Imm(3), 'a'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -269,14 +268,14 @@ describe("CmpBinaryOperators", function () {
         let lhs = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(3)),
-            new EcmaXor2dyn(lhs),
-            new EcmaTrystglobalbyname('a'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(3)),
+            new Xor2(new Imm(2), lhs),
+            new Trystglobalbyname(new Imm(3), 'a'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -284,22 +283,23 @@ describe("CmpBinaryOperators", function () {
     it("CommaToken", function () {
         let insns = compileMainSnippet(`let x = 1;
                                 x = (x++, x);`);
-        let variable = new VReg();
         let rhs = new VReg();
         let lhs = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(1)),
-            new EcmaStlettoglobalrecord('x'),
-            new EcmaTryldglobalbyname('x'),
-            new StaDyn(lhs),
-            new EcmaIncdyn(lhs),
-            new EcmaTrystglobalbyname('x'),
-            new EcmaTonumeric(variable),
-            new StaDyn(rhs),
-            new EcmaTryldglobalbyname('x'),
-            new EcmaTrystglobalbyname('x'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(1)),
+            new Sttoglobalrecord(new Imm(0), 'x'),
+            new Tryldglobalbyname(new Imm(1), 'x'),
+            new Sta(lhs),
+            new Lda(lhs),
+            new Inc(new Imm(2)),
+            new Trystglobalbyname(new Imm(3), 'x'),
+            new Lda(new VReg()),
+            new Tonumeric(new Imm(4)),
+            new Sta(rhs),
+            new Tryldglobalbyname(new Imm(5), 'x'),
+            new Trystglobalbyname(new Imm(6), 'x'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -310,10 +310,10 @@ describe("CmpBinaryOperators", function () {
 
         let expected = [
             new LdaStr('o'),
-            new StaDyn(rhs),
-            new EcmaTryldglobalbyname("C"),
-            new EcmaIsindyn(rhs),
-            new EcmaReturnundefined()
+            new Sta(rhs),
+            new Tryldglobalbyname(new Imm(0), "C"),
+            new Isin(new Imm(1), rhs),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -323,11 +323,11 @@ describe("CmpBinaryOperators", function () {
         let rhs = new VReg();
 
         let expected = [
-            new EcmaTryldglobalbyname("o"),
-            new StaDyn(rhs),
-            new EcmaTryldglobalbyname("C"),
-            new EcmaInstanceofdyn(rhs),
-            new EcmaReturnundefined()
+            new Tryldglobalbyname(new Imm(0), "o"),
+            new Sta(rhs),
+            new Tryldglobalbyname(new Imm(1), "C"),
+            new Instanceof(new Imm(2), rhs),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/expression/commalist.test.ts b/ts2panda/tests/expression/commalist.test.ts
index 5163fded64bb57bf427a5643c90c899cc5b69504..c160bda29d4b7058ca82a7657e3a6893d65881d3 100644
--- a/ts2panda/tests/expression/commalist.test.ts
+++ b/ts2panda/tests/expression/commalist.test.ts
@@ -18,16 +18,16 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaReturnundefined,
-    EcmaStglobalvar,
-    EcmaTryldglobalbyname,
+    Returnundefined,
+    Stglobalvar,
+    Tryldglobalbyname,
     Imm,
-    LdaDyn,
-    MovDyn,
-    StaDyn,
-    EcmaDefineclasswithbuffer,
-    EcmaStclasstoglobalrecord,
-    EcmaNewobjdynrange,
+    Lda,
+    Mov,
+    Sta,
+    Defineclasswithbuffer,
+    Sttoglobalrecord,
+    Newobjrange,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, SnippetCompiler } from "../utils/base";
@@ -53,67 +53,67 @@ describe("CommaListExpression", function () {
         "test.ts");
         let insns = snippetCompiler.getGlobalInsns();
         let expected = [
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaDefineclasswithbuffer("#1#Test", new Imm(0), new Imm(0), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new EcmaStclasstoglobalrecord("Test"),
-            new EcmaTryldglobalbyname('WeakMap'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaNewobjdynrange(new Imm(2), [new VReg(), new VReg()]),
-            new EcmaStglobalvar('_Test_filed1'),
-            new EcmaTryldglobalbyname('WeakMap'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaNewobjdynrange(new Imm(2), [new VReg(), new VReg()]),
-            new EcmaStglobalvar('_Test_filed2'),
-            new EcmaTryldglobalbyname('WeakMap'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaNewobjdynrange(new Imm(2), [new VReg(), new VReg()]),
-            new EcmaStglobalvar('_Test_filed3'),
-            new EcmaTryldglobalbyname('WeakMap'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaNewobjdynrange(new Imm(2), [new VReg(), new VReg()]),
-            new EcmaStglobalvar('_Test_filed4'),
-            new EcmaTryldglobalbyname('WeakMap'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaNewobjdynrange(new Imm(2), [new VReg(), new VReg()]),
-            new EcmaStglobalvar('_Test_filed5'),
-            new EcmaTryldglobalbyname('WeakMap'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaNewobjdynrange(new Imm(2), [new VReg(), new VReg()]),
-            new EcmaStglobalvar('_Test_filed6'),
-            new EcmaTryldglobalbyname('WeakMap'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaNewobjdynrange(new Imm(2), [new VReg(), new VReg()]),
-            new EcmaStglobalvar('_Test_filed7'),
-            new EcmaTryldglobalbyname('WeakMap'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaNewobjdynrange(new Imm(2), [new VReg(), new VReg()]),
-            new EcmaStglobalvar('_Test_filed8'),
-            new EcmaTryldglobalbyname('WeakMap'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaNewobjdynrange(new Imm(2), [new VReg(), new VReg()]),
-            new EcmaStglobalvar('_Test_filed9'),
-            new EcmaTryldglobalbyname('WeakMap'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaNewobjdynrange(new Imm(2), [new VReg(), new VReg()]),
-            new EcmaStglobalvar('_Test_filed10'),
-            new EcmaTryldglobalbyname('WeakMap'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaNewobjdynrange(new Imm(2), [new VReg(), new VReg()]),
-            new EcmaStglobalvar('_Test_filed11'),
-            new EcmaReturnundefined()
+            new Mov(new VReg(), new VReg()),
+            new Defineclasswithbuffer(new Imm(0), "#1#Test", "0", new Imm(0), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Sttoglobalrecord(new Imm(1), "Test"),
+            new Tryldglobalbyname(new Imm(2), 'WeakMap'),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Newobjrange(new Imm(3), new Imm(1), [new VReg()]),
+            new Stglobalvar(new Imm(4), '_Test_filed1'),
+            new Tryldglobalbyname(new Imm(5), 'WeakMap'),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Newobjrange(new Imm(6), new Imm(1), [new VReg()]),
+            new Stglobalvar(new Imm(7), '_Test_filed2'),
+            new Tryldglobalbyname(new Imm(8), 'WeakMap'),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Newobjrange(new Imm(9), new Imm(1), [new VReg()]),
+            new Stglobalvar(new Imm(10), '_Test_filed3'),
+            new Tryldglobalbyname(new Imm(11), 'WeakMap'),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Newobjrange(new Imm(12), new Imm(1), [new VReg()]),
+            new Stglobalvar(new Imm(13), '_Test_filed4'),
+            new Tryldglobalbyname(new Imm(14), 'WeakMap'),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Newobjrange(new Imm(15), new Imm(1), [new VReg()]),
+            new Stglobalvar(new Imm(16), '_Test_filed5'),
+            new Tryldglobalbyname(new Imm(17), 'WeakMap'),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Newobjrange(new Imm(18), new Imm(1), [new VReg()]),
+            new Stglobalvar(new Imm(19), '_Test_filed6'),
+            new Tryldglobalbyname(new Imm(20), 'WeakMap'),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Newobjrange(new Imm(21), new Imm(1), [new VReg()]),
+            new Stglobalvar(new Imm(22), '_Test_filed7'),
+            new Tryldglobalbyname(new Imm(23), 'WeakMap'),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Newobjrange(new Imm(24), new Imm(1), [new VReg()]),
+            new Stglobalvar(new Imm(25), '_Test_filed8'),
+            new Tryldglobalbyname(new Imm(26), 'WeakMap'),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Newobjrange(new Imm(27), new Imm(1), [new VReg()]),
+            new Stglobalvar(new Imm(28), '_Test_filed9'),
+            new Tryldglobalbyname(new Imm(29), 'WeakMap'),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Newobjrange(new Imm(30), new Imm(1), [new VReg()]),
+            new Stglobalvar(new Imm(31), '_Test_filed10'),
+            new Tryldglobalbyname(new Imm(32), 'WeakMap'),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Newobjrange(new Imm(33), new Imm(1), [new VReg()]),
+            new Stglobalvar(new Imm(34), '_Test_filed11'),
+            new Returnundefined()
         ]
         expect(checkInstructions(insns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/expression/conditions.test.ts b/ts2panda/tests/expression/conditions.test.ts
index 49a060a7b7ff099f01546b5c2a4f36ea5a9dd2bb..5751ce8b2e04be07b606de2a5f3fa7da9022d7f0 100644
--- a/ts2panda/tests/expression/conditions.test.ts
+++ b/ts2panda/tests/expression/conditions.test.ts
@@ -18,22 +18,20 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaAnd2dyn,
-    EcmaEqdyn,
-    EcmaIsfalse,
-    EcmaIstrue,
-    EcmaReturnundefined,
-    EcmaStlettoglobalrecord,
-    EcmaTryldglobalbyname,
+    And2,
+    Eq,
+    Isfalse,
+    Istrue,
+    Returnundefined,
+    Sttoglobalrecord,
+    Tryldglobalbyname,
     Imm,
     Jeqz,
-    Jlez,
     Jmp,
     Label,
-    LdaDyn,
-    LdaiDyn,
-    ResultType,
-    StaDyn,
+    Lda,
+    Ldai,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
@@ -46,7 +44,7 @@ describe("IfConditionTest", function () {
 
         expect(jumps.length).to.equal(1);
 
-        let targetLabel = (<Jlez>jumps[0]).getTarget();
+        let targetLabel = (<Jeqz>jumps[0]).getTarget();
         // The last instruction is return.
         expect(targetLabel).to.equal(insns[insns.length - 2]);
     });
@@ -60,7 +58,7 @@ describe("IfConditionTest", function () {
 
         expect(jumps.length).to.equal(1);
 
-        let targetLabel = (<Jlez>jumps[0]).getTarget();
+        let targetLabel = (<Jeqz>jumps[0]).getTarget();
         // The last instruction is return.
         expect(targetLabel).to.equal(insns[insns.length - 2]);
     });
@@ -78,7 +76,7 @@ describe("IfConditionTest", function () {
         expect(jumps.length).to.equal(2);
         expect(labels.length).to.equal(2);
 
-        let elseLabel = (<Jlez>jumps[0]).getTarget();
+        let elseLabel = (<Jeqz>jumps[0]).getTarget();
         let endIfLabel = (<Jmp>jumps[1]).getTarget();
 
         expect(elseLabel).to.equal(labels[0]);
@@ -98,15 +96,15 @@ describe("IfConditionTest", function () {
         let lhs = new VReg();
         let endIfLabel = new Label();
         let expected = [
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new EcmaTryldglobalbyname('b'),
-            new EcmaAnd2dyn(lhs),
-            new EcmaIstrue(),
+            new Tryldglobalbyname(new Imm(0), 'a'),
+            new Sta(lhs),
+            new Tryldglobalbyname(new Imm(1), 'b'),
+            new And2(new Imm(2), lhs),
+            new Istrue(),
             new Jeqz(endIfLabel),
             endIfLabel,
         ];
-        insns = insns.slice(4, insns.length - 1); // skip let a = 1; let b = 2; and return.dyn
+        insns = insns.slice(4, insns.length - 1); // skip let a = 1; let b = 2; and return.
         expect(checkInstructions(insns, expected)).to.be.true
     });
 
@@ -121,14 +119,14 @@ describe("IfConditionTest", function () {
         let trueReg = new VReg();
         let endIfLabel = new Label();
         let expected = [
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(a),
-            new EcmaTryldglobalbyname('b'),
-            new EcmaEqdyn(trueReg),
+            new Tryldglobalbyname(new Imm(0), 'a'),
+            new Sta(a),
+            new Tryldglobalbyname(new Imm(1), 'b'),
+            new Eq(new Imm(2), trueReg),
             new Jeqz(endIfLabel),
             endIfLabel,
         ];
-        insns = insns.slice(4, insns.length - 1); // skip let a = 1; let b = 2; and return.dyn
+        insns = insns.slice(4, insns.length - 1); // skip let a = 1; let b = 2; and return.
         expect(checkInstructions(insns, expected)).to.be.true;
     });
 
@@ -139,15 +137,15 @@ describe("IfConditionTest", function () {
         let expectedElseLabel = new Label();
         let expectedEndLabel = new Label();
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaIstrue(),
+            new Lda(new VReg()),
+            new Istrue(),
             new Jeqz(expectedElseLabel),
-            new LdaiDyn(new Imm(5)),
+            new Ldai(new Imm(5)),
             new Jmp(expectedEndLabel),
             expectedElseLabel,
-            new LdaiDyn(new Imm(0)),
+            new Ldai(new Imm(0)),
             expectedEndLabel,
-            new EcmaStlettoglobalrecord('a'),
+            new Sttoglobalrecord(new Imm(0), 'a'),
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
 
@@ -162,14 +160,14 @@ describe("IfConditionTest", function () {
         let insns = compileMainSnippet("if (true && 5) {}");
         let ifFalseLabel = new Label();
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaIstrue(),
+            new Lda(new VReg()),
+            new Istrue(),
             new Jeqz(ifFalseLabel),
-            new LdaiDyn(new Imm(5)),
-            new EcmaIstrue(),
+            new Ldai(new Imm(5)),
+            new Istrue(),
             new Jeqz(ifFalseLabel),
             ifFalseLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ]
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -179,15 +177,15 @@ describe("IfConditionTest", function () {
         let ifFalseLabel = new Label();
         let endLabel = new Label();
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaIsfalse(),
+            new Lda(new VReg()),
+            new Isfalse(),
             new Jeqz(endLabel),
-            new LdaiDyn(new Imm(5)),
-            new EcmaIstrue(),
+            new Ldai(new Imm(5)),
+            new Istrue(),
             new Jeqz(ifFalseLabel),
             endLabel,
             ifFalseLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ]
         expect(checkInstructions(insns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/expression/delete.test.ts b/ts2panda/tests/expression/delete.test.ts
index 9b180f1030747abc9f43a8e396cf1db0eac29081..3b62d4e46a8668b0b35f8cf201682ae1c84201f4 100644
--- a/ts2panda/tests/expression/delete.test.ts
+++ b/ts2panda/tests/expression/delete.test.ts
@@ -18,15 +18,15 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaDelobjprop,
-    EcmaReturnundefined,
-    EcmaStlettoglobalrecord,
-    EcmaTryldglobalbyname,
+    Delobjprop,
+    Returnundefined,
+    Sttoglobalrecord,
+    Tryldglobalbyname,
     Imm,
-    LdaDyn,
-    LdaiDyn,
+    Lda,
+    Ldai,
     LdaStr,
-    StaDyn,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet, SnippetCompiler } from "../utils/base";
@@ -36,16 +36,14 @@ describe("deleteExpressionTest", function () {
         let insns = compileMainSnippet("let arr = [1, 2]; delete arr[1];");
 
         let objReg = new VReg();
-        let propReg = new VReg();
-
+ 
         let expected = [
-            new EcmaStlettoglobalrecord('arr'),
-            new EcmaTryldglobalbyname('arr'),
-            new StaDyn(objReg),
-            new LdaiDyn(new Imm(1)),
-            new StaDyn(propReg),
-            new EcmaDelobjprop(objReg, propReg),
-            new EcmaReturnundefined()
+            new Sttoglobalrecord(new Imm(0), 'arr'),
+            new Tryldglobalbyname(new Imm(1), 'arr'),
+            new Sta(objReg),
+            new Ldai(new Imm(1)),
+            new Delobjprop(new VReg()),
+            new Returnundefined()
         ];
 
         insns = insns.slice(insns.length - 7, insns.length);
@@ -59,17 +57,15 @@ describe("deleteExpressionTest", function () {
                                   b: 2};
                                   delete obj.b;`);
         let objReg = new VReg();
-        let propReg = new VReg();
 
         let expected = [
             // delete obj.b;
-            new EcmaStlettoglobalrecord('obj'),
-            new EcmaTryldglobalbyname('obj'),
-            new StaDyn(objReg),
+            new Sttoglobalrecord(new Imm(0), 'obj'),
+            new Tryldglobalbyname(new Imm(1), 'obj'),
+            new Sta(objReg),
             new LdaStr("b"),
-            new StaDyn(propReg),
-            new EcmaDelobjprop(objReg, propReg),
-            new EcmaReturnundefined()
+            new Delobjprop(new VReg()),
+            new Returnundefined()
         ];
 
         insns = insns.slice(insns.length - 7, insns.length);
@@ -87,9 +83,9 @@ describe("deleteExpressionTest", function () {
         let insns = snippetCompiler.getGlobalInsns();
         let expected = [
             // function call insns
-            new LdaDyn(new VReg()),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Returnundefined()
         ];
 
         insns = insns.slice(insns.length - 3, insns.length);
@@ -101,10 +97,10 @@ describe("deleteExpressionTest", function () {
         let insns = compileMainSnippet(`let a = delete false;`);
 
         let expected = [
-            new LdaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Lda(new VReg()),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -112,14 +108,11 @@ describe("deleteExpressionTest", function () {
 
     it("deleteUnresolvable", function () {
         let insns = compileMainSnippet(`delete a;`);
-        let globalReg = new VReg();
-        let a = new VReg();
 
         let expected = [
             new LdaStr("a"),
-            new StaDyn(a),
-            new EcmaDelobjprop(globalReg, a),
-            new EcmaReturnundefined()
+            new Delobjprop(new VReg()),
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -127,15 +120,12 @@ describe("deleteExpressionTest", function () {
 
     it("double delete", function () {
         let insns = compileMainSnippet(`delete delete a;`);
-        let globalReg = new VReg();
-        let a = new VReg();
 
         let expected = [
             new LdaStr("a"),
-            new StaDyn(a),
-            new EcmaDelobjprop(globalReg, a),
-            new LdaDyn(new VReg()),
-            new EcmaReturnundefined()
+            new Delobjprop(new VReg()),
+            new Lda(new VReg()),
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
diff --git a/ts2panda/tests/expression/elementAccess.test.ts b/ts2panda/tests/expression/elementAccess.test.ts
index f83e34303a3d635c337c16ff282ff5d793dafc84..ba36ec4e5cce7d35f22358043109c581c93b7222 100644
--- a/ts2panda/tests/expression/elementAccess.test.ts
+++ b/ts2panda/tests/expression/elementAccess.test.ts
@@ -18,18 +18,18 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaAdd2dyn,
-    EcmaLdobjbyname,
-    EcmaLdobjbyvalue,
-    EcmaStlettoglobalrecord,
-    EcmaStobjbyname,
-    EcmaTryldglobalbyname,
+    Add2,
+    Ldobjbyname,
+    Ldobjbyvalue,
+    Sttoglobalrecord,
+    Stobjbyname,
+    Tryldglobalbyname,
     Imm,
-    LdaiDyn,
-    MovDyn,
-    ResultType,
-    StaDyn,
-    VReg
+    Ldai,
+    Mov,
+    Sta,
+    VReg,
+    Lda
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
 
@@ -41,13 +41,14 @@ describe("ElementAccess", function () {
         let objReg = new VReg();
 
         let expected = [
-            new EcmaStlettoglobalrecord('obj'),
-            new EcmaTryldglobalbyname('obj'),
-            new StaDyn(objReg),
-            new EcmaLdobjbyname("property", objReg),
+            new Sttoglobalrecord(new Imm(0), 'obj'),
+            new Tryldglobalbyname(new Imm(1), 'obj'),
+            new Sta(objReg),
+            new Lda(objReg),
+            new Ldobjbyname(new Imm(2), "property"),
         ];
 
-        insns = insns.slice(1, insns.length - 1); // cut off let obj and return.dyn
+        insns = insns.slice(1, insns.length - 1); // cut off let obj and return.
         expect(checkInstructions(insns, expected)).to.be.true;
     });
 
@@ -58,15 +59,15 @@ describe("ElementAccess", function () {
         let tempObj = new VReg();
 
         let expected = [
-            new EcmaStlettoglobalrecord('obj'),
-            new EcmaTryldglobalbyname('obj'),
-            new StaDyn(tempObj),
-            new MovDyn(objReg, tempObj),
-            new LdaiDyn(new Imm(5)),
-            new EcmaStobjbyname("property", objReg),
+            new Sttoglobalrecord(new Imm(0), 'obj'),
+            new Tryldglobalbyname(new Imm(1), 'obj'),
+            new Sta(tempObj),
+            new Mov(objReg, tempObj),
+            new Ldai(new Imm(5)),
+            new Stobjbyname(new Imm(2), "property", objReg),
         ];
 
-        insns = insns.slice(1, insns.length - 1); // cut off let obj and return.dyn
+        insns = insns.slice(1, insns.length - 1); // cut off let obj and return.
         expect(checkInstructions(insns, expected)).to.be.true;
     });
 
@@ -78,17 +79,18 @@ describe("ElementAccess", function () {
         let val = new VReg();
 
         let expected = [
-            new EcmaStlettoglobalrecord('obj'),
-            new EcmaTryldglobalbyname('obj'),
-            new StaDyn(objReg),
-            new LdaiDyn(new Imm(1)),
-            new StaDyn(prop1Reg),
-            new LdaiDyn(new Imm(2)),
-            new EcmaAdd2dyn(prop1Reg),
-            new StaDyn(val),
-            new EcmaLdobjbyvalue(objReg, val)
+            new Sttoglobalrecord(new Imm(0), 'obj'),
+            new Tryldglobalbyname(new Imm(1), 'obj'),
+            new Sta(objReg),
+            new Ldai(new Imm(1)),
+            new Sta(prop1Reg),
+            new Ldai(new Imm(2)),
+            new Add2(new Imm(2), prop1Reg),
+            new Sta(val),
+            new Lda(val),
+            new Ldobjbyvalue(new Imm(3), objReg)
         ];
-        insns = insns.slice(1, insns.length - 1); // cut off let obj and return.dyn
+        insns = insns.slice(1, insns.length - 1); // cut off let obj and return.
         expect(checkInstructions(insns, expected)).to.be.true;
     });
 });
diff --git a/ts2panda/tests/expression/functionExpression.test.ts b/ts2panda/tests/expression/functionExpression.test.ts
index e04bb8ea3ed2cae536798ee94c35d6a2d1de935d..7e52a3a33b14391f2446efedab31fcc955b5065e 100644
--- a/ts2panda/tests/expression/functionExpression.test.ts
+++ b/ts2panda/tests/expression/functionExpression.test.ts
@@ -16,32 +16,29 @@
 import { expect } from 'chai';
 import { DiagnosticCode, DiagnosticError } from '../../src/diagnostic';
 import {
-    EcmaAdd2dyn,
-    EcmaAsyncfunctionawaituncaught,
-    EcmaAsyncfunctionenter,
-    EcmaAsyncfunctionreject,
-    EcmaAsyncfunctionresolve,
-    EcmaCallarg0dyn,
-    EcmaCreategeneratorobj,
-    EcmaCreateiterresultobj,
-    EcmaDefinefuncdyn,
-    EcmaDefinegeneratorfunc,
-    EcmaDefinencfuncdyn,
-    EcmaEqdyn,
-    EcmaGetresumemode,
-    EcmaLdlexenvdyn,
-    EcmaResumegenerator,
-    EcmaReturnundefined,
-    EcmaSuspendgenerator,
-    EcmaThrowdyn,
-    EcmaLdfunction,
+    Add2,
+    Asyncfunctionawaituncaught,
+    Asyncfunctionenter,
+    Asyncfunctionreject,
+    Asyncfunctionresolve,
+    Callarg0,
+    Creategeneratorobj,
+    Createiterresultobj,
+    Definefunc,
+    Eq,
+    Getresumemode,
+    Resumegenerator,
+    Returnundefined,
+    Suspendgenerator,
+    Throw,
+    Ldfunction,
     Imm,
     Jeqz,
     Label,
-    LdaDyn,
-    LdaiDyn,
-    ReturnDyn,
-    StaDyn,
+    Lda,
+    Ldai,
+    Return,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { CacheExpander } from '../../src/pass/cacheExpander';
@@ -58,16 +55,16 @@ describe("compileFunctionExpression", function () {
         let pandaGens = compileAllSnippet(source, passes);
 
         let expected_func = [
-            new EcmaLdlexenvdyn(),
-            new StaDyn(new VReg()),
-            new EcmaLdfunction(),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaCallarg0dyn(new VReg()),
-            new EcmaReturnundefined()
+            new Sta(new VReg()),
+            new Ldfunction(),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Callarg0(new Imm(0)),
+            new Returnundefined()
         ];
 
         let checkCount = 0;
@@ -97,7 +94,7 @@ describe("compileFunctionExpression", function () {
             if (pg.internalName == "func_main_0") {
 
                 pg.getInsns().forEach((insns) => {
-                    if (insns instanceof EcmaDefinefuncdyn) {
+                    if (insns instanceof Definefunc) {
                         expect(insns.operands[0]).to.equal('a');
                         checkCount++;
                     }
@@ -125,7 +122,7 @@ describe("compileFunctionExpression", function () {
             if (pg.internalName == "func_main_0") {
 
                 pg.getInsns().forEach((insns) => {
-                    if (insns instanceof EcmaDefinefuncdyn) {
+                    if (insns instanceof Definefunc) {
                         expect(insns.operands[0]).to.equal('a');
                         checkCount++;
                     }
@@ -153,7 +150,7 @@ describe("compileFunctionExpression", function () {
             if (pg.internalName == "func_main_0") {
 
                 pg.getInsns().forEach((insns) => {
-                    if (insns instanceof EcmaDefinencfuncdyn) {
+                    if (insns instanceof Definefunc) {
                         expect(insns.operands[0]).to.equal('a');
                         checkCount++;
                     }
@@ -172,13 +169,13 @@ describe("compileFunctionExpression", function () {
         let checkCount = 0;
 
         let expected_func = [
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new EcmaAdd2dyn(new VReg()),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new ReturnDyn()
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Add2(new Imm(0), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Return()
         ];
 
         pandaGens.forEach((pg) => {
@@ -190,7 +187,7 @@ describe("compileFunctionExpression", function () {
             if (pg.internalName == "func_main_0") {
 
                 pg.getInsns().forEach((insns) => {
-                    if (insns instanceof EcmaDefinencfuncdyn) {
+                    if (insns instanceof Definefunc) {
                         expect(insns.operands[0]).to.equal('p');
                         checkCount++;
                     }
@@ -228,55 +225,59 @@ describe("compileFunctionExpression", function () {
         let notThrowLabel1 = new Label();
 
         let expected_func = [
-            new EcmaCreategeneratorobj(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaSuspendgenerator(new VReg(), new VReg()),
-            new EcmaResumegenerator(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaGetresumemode(new VReg()),
-            new StaDyn(new VReg()),
-
-            new LdaiDyn(new Imm(0)),
-            new EcmaEqdyn(new VReg()),
+            new Creategeneratorobj(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Suspendgenerator(new VReg()),
+            new Lda(new VReg()),
+            new Resumegenerator(),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Getresumemode(),
+            new Sta(new VReg()),
+
+            new Ldai(new Imm(0)),
+            new Eq(new Imm(0), new VReg()),
             new Jeqz(notRetLabel0),
-            new LdaDyn(new VReg()),
-            new ReturnDyn(),
+            new Lda(new VReg()),
+            new Return(),
 
             notRetLabel0,
-            new LdaiDyn(new Imm(1)),
-            new EcmaEqdyn(new VReg()),
+            new Ldai(new Imm(1)),
+            new Eq(new Imm(1), new VReg()),
             new Jeqz(notThrowLabel0),
-            new LdaDyn(new VReg()),
-            new EcmaThrowdyn(),
+            new Lda(new VReg()),
+            new Throw(),
 
             notThrowLabel0,
-            new LdaDyn(new VReg()),
-            new LdaiDyn(new Imm(1)),
-            new StaDyn(new VReg()),
-            new EcmaCreateiterresultobj(new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaSuspendgenerator(new VReg(), new VReg()),
-            new EcmaResumegenerator(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaGetresumemode(new VReg()),
-            new StaDyn(new VReg()),
-
-            new LdaiDyn(new Imm(0)),
-            new EcmaEqdyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldai(new Imm(1)),
+            new Sta(new VReg()),
+            new Createiterresultobj(new VReg(), new VReg()),
+            new Suspendgenerator(new VReg()),
+            new Lda(new VReg()),
+            new Resumegenerator(),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Getresumemode(),
+            new Sta(new VReg()),
+
+            new Ldai(new Imm(0)),
+            new Eq(new Imm(2), new VReg()),
             new Jeqz(notRetLabel1),
-            new LdaDyn(new VReg()),
-            new ReturnDyn(),
+            new Lda(new VReg()),
+            new Return(),
 
             notRetLabel1,
-            new LdaiDyn(new Imm(1)),
-            new EcmaEqdyn(new VReg()),
+            new Ldai(new Imm(1)),
+            new Eq(new Imm(3), new VReg()),
             new Jeqz(notThrowLabel1),
-            new LdaDyn(new VReg()),
-            new EcmaThrowdyn(),
+            new Lda(new VReg()),
+            new Throw(),
 
             notThrowLabel1,
-            new LdaDyn(new VReg()),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Returnundefined()
         ];
 
         let pandaGens = compileAllSnippet(source);
@@ -290,7 +291,7 @@ describe("compileFunctionExpression", function () {
 
             if (pg.internalName == "func_main_0") {
                 pg.getInsns().forEach((insns) => {
-                    if (insns instanceof EcmaDefinegeneratorfunc) {
+                    if (insns instanceof Definefunc) {
                         expect(insns.operands[0]).to.equal('a');
                         checkCount++;
                     }
@@ -312,31 +313,37 @@ describe("compileFunctionExpression", function () {
         let nextLabel = new Label();
 
         let expected_func = [
-            new EcmaAsyncfunctionenter(),
-            new StaDyn(new VReg()),
+            new Asyncfunctionenter(),
+            new Sta(new VReg()),
             beginLabel,
-            new LdaiDyn(new Imm(1)),
-            new StaDyn(new VReg()),
-            new EcmaAsyncfunctionawaituncaught(new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaSuspendgenerator(new VReg(), new VReg()),
-            new EcmaResumegenerator(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaGetresumemode(new VReg()),
-            new StaDyn(new VReg()),
-            new LdaiDyn(new Imm(1)),
-            new EcmaEqdyn(new VReg()),
+            new Ldai(new Imm(1)),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Asyncfunctionawaituncaught(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Suspendgenerator(new VReg()),
+            new Lda(new VReg()),
+            new Resumegenerator(),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Getresumemode(),
+            new Sta(new VReg()),
+            new Ldai(new Imm(1)),
+            new Eq(new Imm(0), new VReg()),
             new Jeqz(nextLabel),
-            new LdaDyn(new VReg()),
-            new EcmaThrowdyn(),
+            new Lda(new VReg()),
+            new Throw(),
             nextLabel,
-            new LdaDyn(new VReg()),
-            new EcmaAsyncfunctionresolve(new VReg(), new VReg(), new VReg()),
-            new ReturnDyn(),
+            new Lda(new VReg()),
+            new Lda(new VReg()),
+            new Asyncfunctionresolve(new VReg()),
+            new Return(),
             endLabel,
-            new StaDyn(new VReg()),
-            new EcmaAsyncfunctionreject(new VReg(), new VReg(), new VReg()),
-            new ReturnDyn(),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Asyncfunctionreject(new VReg()),
+            new Return(),
         ];
 
         let pandaGens = compileAllSnippet(source);
@@ -350,7 +357,7 @@ describe("compileFunctionExpression", function () {
 
             if (pg.internalName == "func_main_0") {
                 pg.getInsns().forEach((insns) => {
-                    if (insns instanceof EcmaDefinencfuncdyn) {
+                    if (insns instanceof Definefunc) {
                         expect(insns.operands[0]).to.equal('a');
                         checkCount++;
                     }
diff --git a/ts2panda/tests/expression/literal.test.ts b/ts2panda/tests/expression/literal.test.ts
index 1bc73e39bb873d8863cfd8969d3c9eb18589e9a3..95f850de12ed594edd7a6916f04382cebbe9fdcc 100644
--- a/ts2panda/tests/expression/literal.test.ts
+++ b/ts2panda/tests/expression/literal.test.ts
@@ -19,25 +19,24 @@ import {
 import 'mocha';
 import { DiagnosticCode, DiagnosticError } from '../../src/diagnostic';
 import {
-    EcmaAdd2dyn,
-    EcmaCreatearraywithbuffer,
-    EcmaCreateemptyarray,
-    EcmaCreateemptyobject,
-    EcmaCreateobjectwithbuffer,
-    EcmaIncdyn,
-    EcmaReturnundefined,
-    EcmaStarrayspread,
-    EcmaStlettoglobalrecord,
-    EcmaStownbyindex,
-    EcmaStownbyname,
-    EcmaStownbyvalue,
-    EcmaTryldglobalbyname,
+    Add2,
+    Createarraywithbuffer,
+    Createemptyarray,
+    Createemptyobject,
+    Createobjectwithbuffer,
+    Inc,
+    Returnundefined,
+    Starrayspread,
+    Sttoglobalrecord,
+    Stownbyindex,
+    Stownbyname,
+    Stownbyvalue,
+    Tryldglobalbyname,
     Imm,
-    LdaDyn,
-    LdaiDyn,
+    Lda,
+    Ldai,
     LdaStr,
-    ResultType,
-    StaDyn,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
@@ -46,8 +45,8 @@ describe("LiteralTest", function () {
     it("5", function () {
         let insns = compileMainSnippet("5");
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -56,7 +55,7 @@ describe("LiteralTest", function () {
         let insns = compileMainSnippet("\"stringLiteral\"");
         let expected = [
             new LdaStr("stringLiteral"),
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -64,8 +63,8 @@ describe("LiteralTest", function () {
     it("true", function () {
         let insns = compileMainSnippet("true");
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -73,8 +72,8 @@ describe("LiteralTest", function () {
     it("false", function () {
         let insns = compileMainSnippet("false");
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -82,8 +81,8 @@ describe("LiteralTest", function () {
     it("null", function () {
         let insns = compileMainSnippet("null");
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -93,11 +92,11 @@ describe("LiteralTest", function () {
         let arrayInstance = new VReg();
 
         let expected = [
-            new EcmaCreatearraywithbuffer(new Imm(0)),
-            new StaDyn(arrayInstance),
-            new LdaDyn(arrayInstance),
-            new EcmaStlettoglobalrecord('arr'),
-            new EcmaReturnundefined()
+            new Createarraywithbuffer(new Imm(0), "0"),
+            new Sta(arrayInstance),
+            new Lda(arrayInstance),
+            new Sttoglobalrecord(new Imm(1), 'arr'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -107,10 +106,10 @@ describe("LiteralTest", function () {
         let arrayInstance = new VReg();
 
         let expected = [
-            new EcmaCreateemptyarray(),
-            new StaDyn(arrayInstance),
-            new EcmaStlettoglobalrecord('arr'),
-            new EcmaReturnundefined()
+            new Createemptyarray(new Imm(0)),
+            new Sta(arrayInstance),
+            new Sttoglobalrecord(new Imm(1), 'arr'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -120,11 +119,11 @@ describe("LiteralTest", function () {
         let arrayInstance = new VReg();
 
         let expected = [
-            new EcmaCreatearraywithbuffer(new Imm(0)),
-            new StaDyn(arrayInstance),
-            new LdaDyn(arrayInstance),
-            new EcmaStlettoglobalrecord('arr'),
-            new EcmaReturnundefined()
+            new Createarraywithbuffer(new Imm(0), "0"),
+            new Sta(arrayInstance),
+            new Lda(arrayInstance),
+            new Sttoglobalrecord(new Imm(1), 'arr'),
+            new Returnundefined()
         ];
         insns = insns.slice(0, insns.length);
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -135,13 +134,13 @@ describe("LiteralTest", function () {
         let arrayInstance = new VReg();
 
         let expected = [
-            new EcmaCreateemptyarray(),
-            new StaDyn(arrayInstance),
-            new LdaiDyn(new Imm(1)),
-            new EcmaStownbyindex(arrayInstance, new Imm(1)),
-            new LdaDyn(arrayInstance),
-            new EcmaStlettoglobalrecord('arr'),
-            new EcmaReturnundefined()
+            new Createemptyarray(new Imm(0)),
+            new Sta(arrayInstance),
+            new Ldai(new Imm(1)),
+            new Stownbyindex(new Imm(1), arrayInstance, new Imm(1)),
+            new Lda(arrayInstance),
+            new Sttoglobalrecord(new Imm(3), 'arr'),
+            new Returnundefined()
         ];
         insns = insns.slice(0, insns.length);
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -152,13 +151,13 @@ describe("LiteralTest", function () {
         let arrayInstance = new VReg();
 
         let expected = [
-            new EcmaCreatearraywithbuffer(new Imm(0)),
-            new StaDyn(arrayInstance),
-            new LdaiDyn(new Imm(3)),
-            new EcmaStownbyindex(arrayInstance, new Imm(2)),
-            new LdaDyn(arrayInstance),
-            new EcmaStlettoglobalrecord('arr'),
-            new EcmaReturnundefined()
+            new Createarraywithbuffer(new Imm(0), "0"),
+            new Sta(arrayInstance),
+            new Ldai(new Imm(3)),
+            new Stownbyindex(new Imm(1), arrayInstance, new Imm(2)),
+            new Lda(arrayInstance),
+            new Sttoglobalrecord(new Imm(3), 'arr'),
+            new Returnundefined()
         ];
 
         insns = insns.slice(0, insns.length);
@@ -172,24 +171,25 @@ describe("LiteralTest", function () {
         let arrayInstance = new VReg();
 
         let expected = [
-            new EcmaCreatearraywithbuffer(new Imm(0)),
-            new StaDyn(arrayInstance),
-            new LdaDyn(arrayInstance),
-            new EcmaStlettoglobalrecord('arr1'),
-
-            new EcmaCreatearraywithbuffer(new Imm(1)),
-            new StaDyn(arrayInstance),
-            new LdaiDyn(new Imm(1)),
-            new StaDyn(elemIdxReg),
-            new EcmaTryldglobalbyname('arr1'),
-            new EcmaStarrayspread(arrayInstance, elemIdxReg),
-            new StaDyn(elemIdxReg),
-            new LdaiDyn(new Imm(3)),
-            new EcmaStownbyvalue(arrayInstance, elemIdxReg),
-            new EcmaIncdyn(elemIdxReg),
-            new StaDyn(elemIdxReg),
-            new LdaDyn(arrayInstance),
-            new EcmaStlettoglobalrecord('arr'),
+            new Createarraywithbuffer(new Imm(0), "0"),
+            new Sta(arrayInstance),
+            new Lda(arrayInstance),
+            new Sttoglobalrecord(new Imm(1), 'arr1'),
+
+            new Createarraywithbuffer(new Imm(2), "1"),
+            new Sta(arrayInstance),
+            new Ldai(new Imm(1)),
+            new Sta(elemIdxReg),
+            new Tryldglobalbyname(new Imm(3), 'arr1'),
+            new Starrayspread(arrayInstance, elemIdxReg),
+            new Sta(elemIdxReg),
+            new Ldai(new Imm(3)),
+            new Stownbyvalue(new Imm(4), arrayInstance, elemIdxReg),
+            new Lda(elemIdxReg),
+            new Inc(new Imm(6)),
+            new Sta(elemIdxReg),
+            new Lda(arrayInstance),
+            new Sttoglobalrecord(new Imm(7), 'arr'),
         ];
         insns = insns.slice(0, insns.length - 1);
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -200,11 +200,11 @@ describe("LiteralTest", function () {
         let objInstance = new VReg();
 
         let expected = [
-            new EcmaCreateemptyobject(),
-            new StaDyn(objInstance),
+            new Createemptyobject(),
+            new Sta(objInstance),
 
-            new EcmaStlettoglobalrecord('obj'),
-            new EcmaReturnundefined()
+            new Sttoglobalrecord(new Imm(0), 'obj'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -213,11 +213,11 @@ describe("LiteralTest", function () {
         let insns = compileMainSnippet("let obj = {a: 1}");
         let objInstance = new VReg();
         let expected = [
-            new EcmaCreateobjectwithbuffer(new Imm(0)),
-            new StaDyn(objInstance),
-            new LdaDyn(objInstance),
-            new EcmaStlettoglobalrecord('obj'),
-            new EcmaReturnundefined()
+            new Createobjectwithbuffer(new Imm(0), "0"),
+            new Sta(objInstance),
+            new Lda(objInstance),
+            new Sttoglobalrecord(new Imm(1), 'obj'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -228,16 +228,16 @@ describe("LiteralTest", function () {
         let lhs = new VReg();
 
         let expected = [
-            new EcmaCreateobjectwithbuffer(new Imm(0)),
-            new StaDyn(objInstance),
-            new LdaiDyn(new Imm(1)),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(2)),
-            new EcmaAdd2dyn(lhs),
-            new EcmaStownbyindex(objInstance, new Imm(0)),
-            new LdaDyn(objInstance),
-            new EcmaStlettoglobalrecord('obj'),
-            new EcmaReturnundefined()
+            new Createobjectwithbuffer(new Imm(0), "0"),
+            new Sta(objInstance),
+            new Ldai(new Imm(1)),
+            new Sta(lhs),
+            new Ldai(new Imm(2)),
+            new Add2(new Imm(1), lhs),
+            new Stownbyindex(new Imm(2), objInstance, new Imm(0)),
+            new Lda(objInstance),
+            new Sttoglobalrecord(new Imm(4), 'obj'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -247,11 +247,11 @@ describe("LiteralTest", function () {
         let objInstance = new VReg();
 
         let expected = [
-            new EcmaCreateobjectwithbuffer(new Imm(0)),
-            new StaDyn(objInstance),
-            new LdaDyn(objInstance),
-            new EcmaStlettoglobalrecord('obj'),
-            new EcmaReturnundefined()
+            new Createobjectwithbuffer(new Imm(0), "0"),
+            new Sta(objInstance),
+            new Lda(objInstance),
+            new Sttoglobalrecord(new Imm(1), 'obj'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -261,12 +261,12 @@ describe("LiteralTest", function () {
         let objInstance = new VReg();
 
         let expected = [
-            new EcmaCreateobjectwithbuffer(new Imm(0)),
-            new StaDyn(objInstance),
-            new EcmaTryldglobalbyname('a'),
-            new EcmaStownbyname("a", objInstance),
-            new LdaDyn(objInstance),
-            new EcmaStlettoglobalrecord('obj')
+            new Createobjectwithbuffer(new Imm(0), "0"),
+            new Sta(objInstance),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Stownbyname(new Imm(2), "a", objInstance),
+            new Lda(objInstance),
+            new Sttoglobalrecord(new Imm(4), 'obj')
         ];
         insns = insns.slice(2, insns.length - 1);
         expect(checkInstructions(insns, expected)).to.be.true;
diff --git a/ts2panda/tests/expression/logicBinary.test.ts b/ts2panda/tests/expression/logicBinary.test.ts
index 142641503f02a4f9b42d3b5e40c152d95b5c4c9a..1afe0c972ba95a86d92d0178731c0e656838c5bc 100644
--- a/ts2panda/tests/expression/logicBinary.test.ts
+++ b/ts2panda/tests/expression/logicBinary.test.ts
@@ -18,16 +18,16 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaIsfalse,
-    EcmaIstrue,
-    EcmaReturnundefined,
+    Isfalse,
+    Istrue,
+    Returnundefined,
     Imm,
     Jeqz,
     Jmp,
     Label,
-    LdaDyn,
-    LdaiDyn, ResultType,
-    StaDyn,
+    Lda,
+    Ldai,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
@@ -41,16 +41,16 @@ describe("LogicBinaryOperators", function () {
         let postLabel = new Label();
 
         let expected = [
-            new LdaiDyn(new Imm(8)),
-            new StaDyn(lhs),
-            new EcmaIstrue(),
+            new Ldai(new Imm(8)),
+            new Sta(lhs),
+            new Istrue(),
             new Jeqz(preLabel),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(postLabel),
             preLabel,
-            new LdaDyn(lhs),
+            new Lda(lhs),
             postLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ]
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -62,16 +62,16 @@ describe("LogicBinaryOperators", function () {
         let preLabel = new Label();
         let postLabel = new Label();
         let expected = [
-            new LdaiDyn(new Imm(8)),
-            new StaDyn(lhs),
-            new EcmaIsfalse(),
+            new Ldai(new Imm(8)),
+            new Sta(lhs),
+            new Isfalse(),
             new Jeqz(preLabel),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(postLabel),
             preLabel,
-            new LdaDyn(lhs),
+            new Lda(lhs),
             postLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ]
 
         expect(checkInstructions(insns, expected)).to.be.true;
diff --git a/ts2panda/tests/expression/new.test.ts b/ts2panda/tests/expression/new.test.ts
index 1689f46ea7b7c768473aff673a99567b68852f0b..318337e0a6364a427be1cedd71c76760cbf1f8f1 100644
--- a/ts2panda/tests/expression/new.test.ts
+++ b/ts2panda/tests/expression/new.test.ts
@@ -18,19 +18,18 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaCreateemptyarray,
-    EcmaLdobjbyname,
-    EcmaNewobjdynrange,
-    EcmaNewobjspreaddyn,
-    EcmaReturnundefined,
-    EcmaStarrayspread,
-    EcmaTryldglobalbyname,
+    Createemptyarray,
+    Ldobjbyname,
+    Newobjrange,
+    Newobjapply,
+    Returnundefined,
+    Starrayspread,
+    Tryldglobalbyname,
     Imm,
-    LdaDyn,
-    LdaiDyn,
-    MovDyn,
-    ResultType,
-    StaDyn,
+    Lda,
+    Ldai,
+    Mov,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
@@ -39,16 +38,14 @@ describe("NewTest", function () {
     it("new Object", function () {
         let insns = compileMainSnippet("new Object");
         let arg0 = new VReg();
-        let targetReg = new VReg();
 
         let expected = [
-            new EcmaTryldglobalbyname("Object"),
-            new StaDyn(arg0),
-            new MovDyn(targetReg, arg0),
+            new Tryldglobalbyname(new Imm(0), "Object"),
+            new Sta(arg0),
 
-            new EcmaNewobjdynrange(new Imm(2), [arg0, targetReg]),
+            new Newobjrange(new Imm(1), new Imm(1), [arg0]),
 
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -57,16 +54,14 @@ describe("NewTest", function () {
     it("new Object()", function () {
         let insns = compileMainSnippet("new Object()");
         let arg0 = new VReg();
-        let targetReg = new VReg();
 
         let expected = [
-            new EcmaTryldglobalbyname("Object"),
-            new StaDyn(arg0),
-            new MovDyn(targetReg, arg0),
+            new Tryldglobalbyname(new Imm(0), "Object"),
+            new Sta(arg0),
 
-            new EcmaNewobjdynrange(new Imm(2), [arg0, targetReg]),
+            new Newobjrange(new Imm(1), new Imm(1), [arg0]),
 
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -76,19 +71,17 @@ describe("NewTest", function () {
         let insns = compileMainSnippet("new Object(2)");
         let arg0 = new VReg();
         let arg1 = new VReg();
-        let targetReg = new VReg();
 
         let expected = [
-            new EcmaTryldglobalbyname("Object"),
-            new StaDyn(arg0),
-            new MovDyn(targetReg, arg0),
+            new Tryldglobalbyname(new Imm(0), "Object"),
+            new Sta(arg0),
 
-            new LdaiDyn(new Imm(2)),
-            new StaDyn(arg1),
+            new Ldai(new Imm(2)),
+            new Sta(arg1),
 
-            new EcmaNewobjdynrange(new Imm(3), [arg0, targetReg, arg1]),
+            new Newobjrange(new Imm(1), new Imm(2), [arg0, arg1]),
 
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -99,17 +92,16 @@ describe("NewTest", function () {
         let obj = new VReg();
         let arg0 = new VReg();
         let temp = new VReg();
-        let targetReg = new VReg();
 
         let expected = [
-            new EcmaTryldglobalbyname('obj'),
-            new StaDyn(temp),
+            new Tryldglobalbyname(new Imm(0), 'obj'),
+            new Sta(temp),
 
-            new EcmaLdobjbyname("ctor", obj),
-            new StaDyn(arg0),
-            new MovDyn(targetReg, arg0),
+            new Lda(obj),
+            new Ldobjbyname(new Imm(1), "ctor"),
+            new Sta(arg0),
 
-            new EcmaNewobjdynrange(new Imm(2), [arg0, targetReg]),
+            new Newobjrange(new Imm(3), new Imm(1), [arg0]),
         ];
 
         insns = insns.slice(2, insns.length - 1);
@@ -121,27 +113,25 @@ describe("NewTest", function () {
         let insns = compileMainSnippet(`new Object(...args);`);
         let arg0 = new VReg();
         let elemIdxReg = new VReg();
-        let targetReg = new VReg();
         let arrayInstance = new VReg();
 
         let expected = [
-            new EcmaTryldglobalbyname("Object"),
-            new StaDyn(arg0),
-            new MovDyn(targetReg, arg0),
+            new Tryldglobalbyname(new Imm(0), "Object"),
+            new Sta(arg0),
 
-            new EcmaCreateemptyarray(),
-            new StaDyn(arrayInstance),
-            new LdaiDyn(new Imm(0)),
-            new StaDyn(elemIdxReg),
+            new Createemptyarray(new Imm(1)),
+            new Sta(arrayInstance),
+            new Ldai(new Imm(0)),
+            new Sta(elemIdxReg),
 
-            new EcmaTryldglobalbyname("args"),
-            new EcmaStarrayspread(arrayInstance, elemIdxReg),
-            new StaDyn(elemIdxReg),
-            new LdaDyn(arrayInstance),
+            new Tryldglobalbyname(new Imm(2), "args"),
+            new Starrayspread(arrayInstance, elemIdxReg),
+            new Sta(elemIdxReg),
+            new Lda(arrayInstance),
 
-            new EcmaNewobjspreaddyn(arg0, targetReg),
+            new Newobjapply(new Imm(3), arg0),
 
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
diff --git a/ts2panda/tests/expression/numericLiteral.test.ts b/ts2panda/tests/expression/numericLiteral.test.ts
index 2444d29d9bbaa9ca0c5c9da3db078ab4daa307e2..89df3c3faef0ea451dc9d2108ecad1095e0b6120 100644
--- a/ts2panda/tests/expression/numericLiteral.test.ts
+++ b/ts2panda/tests/expression/numericLiteral.test.ts
@@ -17,11 +17,10 @@ import { expect } from 'chai';
 import * as ts from "typescript";
 import { compileNumericLiteral } from "../../src/expression/numericLiteral";
 import {
-    FldaiDyn,
+    Fldai,
     Imm,
-    LdaDyn,
-    LdaiDyn,
-    ResultType,
+    Lda,
+    Ldai,
     VReg
 } from "../../src/irnodes";
 import { PandaGen } from "../../src/pandagen";
@@ -33,7 +32,7 @@ describe("compileNumericLiteral", function () {
         let node: ts.NumericLiteral = ts.createNumericLiteral("NaN");
         compileNumericLiteral(pandaGen, node);
         let insns = pandaGen.getInsns();
-        let expected = [new LdaDyn(new VReg())];
+        let expected = [new Lda(new VReg())];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
 
@@ -42,7 +41,7 @@ describe("compileNumericLiteral", function () {
         let node: ts.NumericLiteral = ts.createNumericLiteral("10e10000");
         compileNumericLiteral(pandaGen, node);
         let insns = pandaGen.getInsns();
-        let expected = [new LdaDyn(new VReg())];
+        let expected = [new Lda(new VReg())];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
     it("int", function () {
@@ -50,7 +49,7 @@ describe("compileNumericLiteral", function () {
         let node: ts.NumericLiteral = ts.createNumericLiteral("1");
         compileNumericLiteral(pandaGen, node);
         let insns = pandaGen.getInsns();
-        let expected = [new LdaiDyn(new Imm(1))];
+        let expected = [new Ldai(new Imm(1))];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
     it("Integer overflow", function () {
@@ -58,7 +57,7 @@ describe("compileNumericLiteral", function () {
         let node: ts.NumericLiteral = ts.createNumericLiteral("2147483648");
         compileNumericLiteral(pandaGen, node);
         let insns = pandaGen.getInsns();
-        let expected = [new FldaiDyn(new Imm(2147483648))];
+        let expected = [new Fldai(new Imm(2147483648))];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
     it("double", function () {
@@ -66,7 +65,7 @@ describe("compileNumericLiteral", function () {
         let node: ts.NumericLiteral = ts.createNumericLiteral("1.1");
         compileNumericLiteral(pandaGen, node);
         let insns = pandaGen.getInsns();
-        let expected = [new FldaiDyn(new Imm(1.1))];
+        let expected = [new Fldai(new Imm(1.1))];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
 })
\ No newline at end of file
diff --git a/ts2panda/tests/expression/operationEqual.test.ts b/ts2panda/tests/expression/operationEqual.test.ts
index ca5ef7b3e6dce20c9c44f131db45c722054b342e..921e0e12f89fb47df1f1e138d7c0f6047f7effdb 100644
--- a/ts2panda/tests/expression/operationEqual.test.ts
+++ b/ts2panda/tests/expression/operationEqual.test.ts
@@ -18,23 +18,22 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaAdd2dyn,
-    EcmaAshr2dyn,
-    EcmaDiv2dyn,
-    EcmaExpdyn,
-    EcmaMod2dyn,
-    EcmaMul2dyn,
-    EcmaReturnundefined,
-    EcmaShl2dyn,
-    EcmaShr2dyn,
-    EcmaStlettoglobalrecord,
-    EcmaSub2dyn,
-    EcmaTryldglobalbyname,
-    EcmaTrystglobalbyname,
+    Add2,
+    Ashr2,
+    Div2,
+    Exp,
+    Mod2,
+    Mul2,
+    Returnundefined,
+    Shl2,
+    Shr2,
+    Sttoglobalrecord,
+    Sub2,
+    Tryldglobalbyname,
+    Trystglobalbyname,
     Imm,
-    LdaiDyn,
-    ResultType,
-    StaDyn,
+    Ldai,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
@@ -46,14 +45,14 @@ describe("OperationEqualTest", function () {
         let lhs = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(2)),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(3)),
-            new EcmaAdd2dyn(lhs),
-            new EcmaTrystglobalbyname('a'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(2)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(3)),
+            new Add2(new Imm(2), lhs),
+            new Trystglobalbyname(new Imm(3), 'a'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -64,14 +63,14 @@ describe("OperationEqualTest", function () {
         let lhs = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(7)),
-            new EcmaSub2dyn(lhs),
-            new EcmaTrystglobalbyname('a'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(7)),
+            new Sub2(new Imm(2), lhs),
+            new Trystglobalbyname(new Imm(3), 'a'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -82,14 +81,14 @@ describe("OperationEqualTest", function () {
         let lhs = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(2)),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(4)),
-            new EcmaMul2dyn(lhs),
-            new EcmaTrystglobalbyname('a'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(2)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(4)),
+            new Mul2(new Imm(2), lhs),
+            new Trystglobalbyname(new Imm(3), 'a'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -100,14 +99,14 @@ describe("OperationEqualTest", function () {
         let lhs = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(2)),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(3)),
-            new EcmaExpdyn(lhs),
-            new EcmaTrystglobalbyname('a'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(2)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(3)),
+            new Exp(new Imm(2), lhs),
+            new Trystglobalbyname(new Imm(3), 'a'),
+            new Returnundefined()
         ]
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -118,14 +117,14 @@ describe("OperationEqualTest", function () {
         let lhs = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(3)),
-            new EcmaDiv2dyn(lhs),
-            new EcmaTrystglobalbyname('a'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(3)),
+            new Div2(new Imm(2), lhs),
+            new Trystglobalbyname(new Imm(3), 'a'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -136,14 +135,14 @@ describe("OperationEqualTest", function () {
         let lhs = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(15)),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(7)),
-            new EcmaMod2dyn(lhs),
-            new EcmaTrystglobalbyname('a'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(15)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(7)),
+            new Mod2(new Imm(2), lhs),
+            new Trystglobalbyname(new Imm(3), 'a'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -154,14 +153,14 @@ describe("OperationEqualTest", function () {
         let lhs = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(8)),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(3)),
-            new EcmaShl2dyn(lhs),
-            new EcmaTrystglobalbyname('a'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(8)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(3)),
+            new Shl2(new Imm(2), lhs),
+            new Trystglobalbyname(new Imm(3), 'a'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -172,14 +171,14 @@ describe("OperationEqualTest", function () {
         let lhs = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(4)),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(1)),
-            new EcmaShr2dyn(lhs),
-            new EcmaTrystglobalbyname('a'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(4)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(1)),
+            new Shr2(new Imm(2), lhs),
+            new Trystglobalbyname(new Imm(3), 'a'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -190,14 +189,14 @@ describe("OperationEqualTest", function () {
         let lhs = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(8)),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(2)),
-            new EcmaAshr2dyn(lhs),
-            new EcmaTrystglobalbyname('a'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(8)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(2)),
+            new Ashr2(new Imm(2), lhs),
+            new Trystglobalbyname(new Imm(3), 'a'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/expression/parenthesized.test.ts b/ts2panda/tests/expression/parenthesized.test.ts
index 370d10e7513d809b564a4454704fa500aa7ea80d..904f42e63678dcd947c51d553ce944aa7dc2ee99 100644
--- a/ts2panda/tests/expression/parenthesized.test.ts
+++ b/ts2panda/tests/expression/parenthesized.test.ts
@@ -18,11 +18,12 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaReturnundefined,
-    EcmaStlettoglobalrecord,
-    EcmaTryldglobalbyname,
-    LdaDyn,
-    VReg
+    Returnundefined,
+    Sttoglobalrecord,
+    Tryldglobalbyname,
+    Lda,
+    VReg,
+    Imm
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
 
@@ -31,10 +32,10 @@ describe("ParenthesizedExpressionTest", function () {
         let insns = compileMainSnippet("let a; (a);");
         let a = new VReg();
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -43,10 +44,10 @@ describe("ParenthesizedExpressionTest", function () {
         let insns = compileMainSnippet("let a; (((a)))");
         let a = new VReg();
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/expression/postfixOperations.test.ts b/ts2panda/tests/expression/postfixOperations.test.ts
index fdd7ad6d1c04cb478ee9290bd367c9eaddcc845a..689d26f27d6935d8b3fbf53201805fd2886340c6 100644
--- a/ts2panda/tests/expression/postfixOperations.test.ts
+++ b/ts2panda/tests/expression/postfixOperations.test.ts
@@ -17,19 +17,20 @@ import {
     expect
 } from 'chai';
 import 'mocha';
+import { loadAccumulator } from 'src/base/bcGenUtil';
 import {
-    EcmaDecdyn,
-    EcmaIncdyn,
-    EcmaReturnundefined,
-    EcmaStlettoglobalrecord,
-    EcmaTonumeric,
-    EcmaTryldglobalbyname,
-    EcmaTrystglobalbyname,
+    Dec,
+    Inc,
+    Returnundefined,
+    Sttoglobalrecord,
+    Tonumeric,
+    Tryldglobalbyname,
+    Trystglobalbyname,
     Imm,
-    LdaiDyn,
-    ResultType,
-    StaDyn,
-    VReg
+    Ldai,
+    Sta,
+    VReg,
+    Lda
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
 
@@ -39,14 +40,16 @@ describe("PostfixOperationsTest", function () {
         let i = new VReg();
         let temp = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('i'),
-            new EcmaTryldglobalbyname('i'),
-            new StaDyn(temp),
-            new EcmaIncdyn(temp),
-            new EcmaTrystglobalbyname('i'),
-            new EcmaTonumeric(i),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'i'),
+            new Tryldglobalbyname(new Imm(1), 'i'),
+            new Sta(temp),
+            new Lda(temp),
+            new Inc(new Imm(2)),
+            new Trystglobalbyname(new Imm(3), 'i'),
+            new Lda(i),
+            new Tonumeric(new Imm(4), ),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -56,14 +59,16 @@ describe("PostfixOperationsTest", function () {
         let i = new VReg();
         let temp = new VReg();
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('i'),
-            new EcmaTryldglobalbyname('i'),
-            new StaDyn(temp),
-            new EcmaDecdyn(temp),
-            new EcmaTrystglobalbyname('i'),
-            new EcmaTonumeric(i),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'i'),
+            new Tryldglobalbyname(new Imm(1), 'i'),
+            new Sta(temp),
+            new Lda(temp),
+            new Dec(new Imm(2)),
+            new Trystglobalbyname(new Imm(3), 'i'),
+            new Lda(i),
+            new Tonumeric(new Imm(4)),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/expression/prefixOperations.test.ts b/ts2panda/tests/expression/prefixOperations.test.ts
index 6cfada76be63979d10686e548890f89904659ca9..79ad82dbf065223fad7c53919d6aca35c34f88e0 100644
--- a/ts2panda/tests/expression/prefixOperations.test.ts
+++ b/ts2panda/tests/expression/prefixOperations.test.ts
@@ -18,22 +18,24 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaDecdyn,
-    EcmaIncdyn,
-    EcmaIstrue,
-    EcmaNegdyn,
-    EcmaNotdyn,
-    EcmaReturnundefined,
-    EcmaStlettoglobalrecord,
-    EcmaTonumber,
-    EcmaTryldglobalbyname,
-    EcmaTrystglobalbyname,
+    Dec,
+    Inc,
+    Istrue,
+    Neg,
+    Not,
+    Returnundefined,
+    Sttoglobalrecord,
+    Tonumber,
+    Tryldglobalbyname,
+    Trystglobalbyname,
     Imm,
     Jeqz,
     Jmp,
     Label,
-    LdaDyn,
-    LdaiDyn, ResultType, StaDyn, VReg
+    Lda,
+    Ldai,
+    Sta,
+    VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
 
@@ -44,14 +46,15 @@ describe("PrefixOperationsTest", function () {
         let temp = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('i'),
-            new EcmaTryldglobalbyname('i'),
-            new StaDyn(temp),
-            new EcmaIncdyn(temp),
-            new EcmaTrystglobalbyname('i'),
-            new EcmaStlettoglobalrecord('j'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'i'),
+            new Tryldglobalbyname(new Imm(1), 'i'),
+            new Sta(temp),
+            new Lda(temp),
+            new Inc(new Imm(2)),
+            new Trystglobalbyname(new Imm(3), 'i'),
+            new Sttoglobalrecord(new Imm(4), 'j'),
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -63,14 +66,15 @@ describe("PrefixOperationsTest", function () {
         let temp = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('i'),
-            new EcmaTryldglobalbyname('i'),
-            new StaDyn(temp),
-            new EcmaDecdyn(temp),
-            new EcmaTrystglobalbyname('i'),
-            new EcmaStlettoglobalrecord('j'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'i'),
+            new Tryldglobalbyname(new Imm(1), 'i'),
+            new Sta(temp),
+            new Lda(temp),
+            new Dec(new Imm(2)),
+            new Trystglobalbyname(new Imm(3), 'i'),
+            new Sttoglobalrecord(new Imm(4), 'j'),
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -82,13 +86,14 @@ describe("PrefixOperationsTest", function () {
         let temp = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('i'),
-            new EcmaTryldglobalbyname('i'),
-            new StaDyn(temp),
-            new EcmaTonumber(temp),
-            new EcmaStlettoglobalrecord('j'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'i'),
+            new Tryldglobalbyname(new Imm(1), 'i'),
+            new Sta(temp),
+            new Lda(temp),
+            new Tonumber(new Imm(2)),
+            new Sttoglobalrecord(new Imm(3), 'j'),
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -100,13 +105,14 @@ describe("PrefixOperationsTest", function () {
         let temp = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('i'),
-            new EcmaTryldglobalbyname('i'),
-            new StaDyn(temp),
-            new EcmaNegdyn(temp),
-            new EcmaStlettoglobalrecord('j'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'i'),
+            new Tryldglobalbyname(new Imm(1), 'i'),
+            new Sta(temp),
+            new Lda(temp),
+            new Neg(new Imm(2)),
+            new Sttoglobalrecord(new Imm(3), 'j'),
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -118,19 +124,19 @@ describe("PrefixOperationsTest", function () {
         let preLabel = new Label();
         let postLabel = new Label();
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('i'),
-            new EcmaTryldglobalbyname('i'),
-            new StaDyn(new VReg()),
-            new EcmaIstrue(),
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'i'),
+            new Tryldglobalbyname(new Imm(1), 'i'),
+            new Sta(new VReg()),
+            new Istrue(),
             new Jeqz(preLabel),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(postLabel),
             preLabel,
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             postLabel,
-            new EcmaStlettoglobalrecord('j'),
-            new EcmaReturnundefined()
+            new Sttoglobalrecord(new Imm(2), 'j'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -141,13 +147,14 @@ describe("PrefixOperationsTest", function () {
         let temp_i = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('i'),
-            new EcmaTryldglobalbyname('i'),
-            new StaDyn(temp_i),
-            new EcmaNotdyn(temp_i),
-            new EcmaStlettoglobalrecord('j'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'i'),
+            new Tryldglobalbyname(new Imm(1), 'i'),
+            new Sta(temp_i),
+            new Lda(temp_i),
+            new Not(new Imm(2)),
+            new Sttoglobalrecord(new Imm(3), 'j'),
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
diff --git a/ts2panda/tests/expression/propertyAccess.test.ts b/ts2panda/tests/expression/propertyAccess.test.ts
index 0fdaf9f488307146d0c5a66ea036d5ad86476f03..4b44770d0b2c57c0e6368308e41a83545fcc3158 100644
--- a/ts2panda/tests/expression/propertyAccess.test.ts
+++ b/ts2panda/tests/expression/propertyAccess.test.ts
@@ -18,19 +18,18 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaCreateobjectwithbuffer,
-    EcmaDefinegettersetterbyvalue,
-    EcmaDefinemethod,
-    EcmaLdobjbyname,
-    EcmaStobjbyname,
-    EcmaTryldglobalbyname,
+    Createobjectwithbuffer,
+    Definegettersetterbyvalue,
+    Definemethod,
+    Ldobjbyname,
+    Stobjbyname,
+    Tryldglobalbyname,
     Imm,
-    LdaDyn,
-    LdaiDyn,
+    Lda,
+    Ldai,
     LdaStr,
-    MovDyn,
-    ResultType,
-    StaDyn,
+    Mov,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileAllSnippet, compileMainSnippet } from "../utils/base";
@@ -43,12 +42,13 @@ describe("PropertyAccess", function () {
         let objReg = new VReg();
 
         let expected = [
-            new EcmaTryldglobalbyname('obj'),
-            new StaDyn(objReg),
-            new EcmaLdobjbyname("property", objReg)
+            new Tryldglobalbyname(new Imm(0), 'obj'),
+            new Sta(objReg),
+            new Lda(objReg),
+            new Ldobjbyname(new Imm(1), "property")
         ];
 
-        insns = insns.slice(2, insns.length - 1); // cut off let obj and return.dyn
+        insns = insns.slice(2, insns.length - 1); // cut off let obj and return.
         expect(checkInstructions(insns, expected)).to.be.true;
     });
 
@@ -59,14 +59,14 @@ describe("PropertyAccess", function () {
         let tempObj = new VReg();
 
         let expected = [
-            new EcmaTryldglobalbyname('obj'),
-            new StaDyn(tempObj),
-            new MovDyn(objReg, tempObj),
-            new LdaiDyn(new Imm(0)),
-            new EcmaStobjbyname("property", objReg),
+            new Tryldglobalbyname(new Imm(0), 'obj'),
+            new Sta(tempObj),
+            new Mov(objReg, tempObj),
+            new Ldai(new Imm(0)),
+            new Stobjbyname(new Imm(1), "property", objReg),
         ];
 
-        insns = insns.slice(2, insns.length - 1); // cut off let obj and return.dyn
+        insns = insns.slice(2, insns.length - 1); // cut off let obj and return.
         expect(checkInstructions(insns, expected)).to.be.true;
     });
 
@@ -83,15 +83,15 @@ describe("PropertyAccess", function () {
         let propReg = new VReg();
 
         let expected = [
-            new EcmaCreateobjectwithbuffer(new Imm(0)),
-            new StaDyn(objInstance),
-            new LdaDyn(new VReg()),
-            new EcmaDefinemethod("myMethod", new Imm(1), new VReg()),
-            new StaDyn(funcReg),
+            new Createobjectwithbuffer(new Imm(0), "0"),
+            new Sta(objInstance),
+            new Lda(new VReg()),
+            new Definemethod(new Imm(1), "myMethod", new Imm(1)),
+            new Sta(funcReg),
             new LdaStr("myMethod"),
-            new StaDyn(propReg),
-            new LdaDyn(new VReg()),
-            new EcmaDefinegettersetterbyvalue(objInstance, propReg, new VReg(), funcReg),
+            new Sta(propReg),
+            new Lda(new VReg()),
+            new Definegettersetterbyvalue(objInstance, propReg, new VReg(), funcReg),
         ];
 
         compilerunit.forEach(element => {
@@ -120,15 +120,15 @@ describe("PropertyAccess", function () {
         let propReg = new VReg();
 
         let expected = [
-            new EcmaCreateobjectwithbuffer(new Imm(0)),
-            new StaDyn(objInstance),
-            new LdaDyn(new VReg()),
-            new EcmaDefinemethod("a", new Imm(0), new VReg()),
-            new StaDyn(funcReg),
+            new Createobjectwithbuffer(new Imm(0), "0"),
+            new Sta(objInstance),
+            new Lda(new VReg()),
+            new Definemethod(new Imm(1), "a", new Imm(0)),
+            new Sta(funcReg),
             new LdaStr("a"),
-            new StaDyn(propReg),
-            new LdaDyn(new VReg()),
-            new EcmaDefinegettersetterbyvalue(objInstance, propReg, funcReg, new VReg()),
+            new Sta(propReg),
+            new Lda(new VReg()),
+            new Definegettersetterbyvalue(objInstance, propReg, funcReg, new VReg()),
         ];
 
         compilerunit.forEach(element => {
@@ -153,18 +153,18 @@ describe("PropertyAccess", function () {
         let propReg = new VReg();
 
         let expected = [
-            new EcmaCreateobjectwithbuffer(new Imm(0)),
-            new StaDyn(objInstance),
-            new LdaDyn(new VReg()),
-            new EcmaDefinemethod("#1#a", new Imm(0), new VReg()),
-            new StaDyn(getterReg),
-            new LdaDyn(new VReg()),
-            new EcmaDefinemethod("#2#a", new Imm(1), new VReg()),
-            new StaDyn(setterReg),
+            new Createobjectwithbuffer(new Imm(0), "0"),
+            new Sta(objInstance),
+            new Lda(new VReg()),
+            new Definemethod(new Imm(1), "#1#a", new Imm(0)),
+            new Sta(getterReg),
+            new Lda(new VReg()),
+            new Definemethod(new Imm(2), "#2#a", new Imm(1)),
+            new Sta(setterReg),
             new LdaStr("a"),
-            new StaDyn(propReg),
-            new LdaDyn(new VReg()),
-            new EcmaDefinegettersetterbyvalue(objInstance, propReg, getterReg, setterReg),
+            new Sta(propReg),
+            new Lda(new VReg()),
+            new Definegettersetterbyvalue(objInstance, propReg, getterReg, setterReg),
         ];
 
         compilerunit.forEach(element => {
diff --git a/ts2panda/tests/expression/regular.test.js b/ts2panda/tests/expression/regular.test.js
index c571350cb06bf7b9e10c38e109c8e5f2a7c3c6b3..1930cf740b8b52fcf2b27a9df181a52d51f756f6 100644
--- a/ts2panda/tests/expression/regular.test.js
+++ b/ts2panda/tests/expression/regular.test.js
@@ -18,10 +18,9 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaCreateregexpwithliteral,
-    EcmaStlettoglobalrecord,
+    Createregexpwithliteral,
+    Sttoglobalrecord,
     Imm,
-    ResultType
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
 
@@ -31,8 +30,8 @@ describe("Regular Expression", function () {
         insns = insns.slice(0, insns.length - 1);
 
         let expected = [
-            new EcmaCreateregexpwithliteral("abc", new Imm(0)),
-            new EcmaStlettoglobalrecord('a')
+            new Createregexpwithliteral(new Imm(0), "abc", new Imm(0)),
+            new Sttoglobalrecord(new Imm(1), 'a')
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -42,8 +41,8 @@ describe("Regular Expression", function () {
         insns = insns.slice(0, insns.length - 1);
 
         let expected = [
-            new EcmaCreateregexpwithliteral("abc", new Imm(2)),
-            new EcmaStlettoglobalrecord('a')
+            new Createregexpwithliteral(new Imm(0), "abc", new Imm(2)),
+            new Sttoglobalrecord(new Imm(1), 'a')
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/expression/templateExpression.test.ts b/ts2panda/tests/expression/templateExpression.test.ts
index c05f3de3c59a7c6755c431da74e7aec75ebb0012..04b5efed3912f5fdbec2d0c023cdd1a078dc4685 100644
--- a/ts2panda/tests/expression/templateExpression.test.ts
+++ b/ts2panda/tests/expression/templateExpression.test.ts
@@ -18,69 +18,76 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaAdd2dyn,
-    EcmaCallithisrangedyn,
-    EcmaCreateemptyarray,
-    EcmaGettemplateobject,
-    EcmaLdobjbyname,
-    EcmaReturnundefined,
-    EcmaStobjbyvalue,
-    EcmaTryldglobalbyname,
+    Add2,
+    Callthisrange,
+    Createemptyarray,
+    Gettemplateobject,
+    Ldobjbyname,
+    Returnundefined,
+    Stobjbyvalue,
+    Tryldglobalbyname,
     Imm,
     IRNode,
-    LdaDyn,
-    LdaiDyn,
+    Lda,
+    Ldai,
     LdaStr,
-    MovDyn,
-    ResultType,
-    StaDyn,
+    Mov,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
 
-function MicroCreateAddInsns(leftVal: number, rightVal: number): IRNode[] {
+function MicroCreateAddInsns(leftVal: number, rightVal: number, icSize: number) {
     let insns = [];
     let lhs = new VReg();
 
-    insns.push(new LdaiDyn(new Imm(leftVal)));
-    insns.push(new StaDyn(lhs));
-    insns.push(new LdaiDyn(new Imm(rightVal)));
-    insns.push(new EcmaAdd2dyn(lhs));
+    insns.push(new Ldai(new Imm(leftVal)));
+    insns.push(new Sta(lhs));
+    insns.push(new Ldai(new Imm(rightVal)));
+    insns.push(new Add2(new Imm(icSize), lhs));
 
-    return insns;
+    let nextIc = icSize + 1;
+
+    return {insns: insns, nextIc: nextIc};
 }
 
-function MicroCreateObjAndPropInsns(): IRNode[] {
+function MicroCreateObjAndPropInsns(icSize: number) {
     let insns = [];
     let obj = new VReg();
     let val = new VReg();
 
-    insns.push(new EcmaTryldglobalbyname("String"));
-    insns.push(new StaDyn(obj));
-    insns.push(new EcmaLdobjbyname("raw", obj));
-    insns.push(new StaDyn(val));
+    insns.push(new Tryldglobalbyname(new Imm(icSize), "String"));
+    insns.push(new Sta(obj));
+    insns.push(new Lda(obj));
+    insns.push(new Ldobjbyname(new Imm(icSize + 1), "raw"));
+    insns.push(new Sta(val));
+
+    let nextIc = icSize + 3;
 
-    return insns;
+    return {insns: insns, nextIc: nextIc};
 }
 
-function MicroGetTemplateObject(rawArr: VReg, cookedArr: VReg): IRNode[] {
+function MicroGetTemplateObject(rawArr: VReg, cookedArr: VReg, icSize: number) {
     let insns = [];
     let objReg = new VReg();
     let indexReg = new VReg();
 
-    insns.push(new EcmaCreateemptyarray());
-    insns.push(new StaDyn(objReg));
+    insns.push(new Createemptyarray(new Imm(icSize)));
+    insns.push(new Sta(objReg));
 
-    insns.push(new LdaiDyn(new Imm(0)));
-    insns.push(new StaDyn(indexReg));
-    insns.push(new LdaDyn(rawArr));
-    insns.push(new EcmaStobjbyvalue(objReg, indexReg));
-    insns.push(new LdaiDyn(new Imm(1)));
-    insns.push(new StaDyn(indexReg));
-    insns.push(new LdaDyn(cookedArr));
-    insns.push(new EcmaStobjbyvalue(objReg, indexReg));
-    insns.push(new EcmaGettemplateobject(objReg));
-    return insns;
+    insns.push(new Ldai(new Imm(0)));
+    insns.push(new Sta(indexReg));
+    insns.push(new Lda(rawArr));
+    insns.push(new Stobjbyvalue(new Imm(icSize + 1), objReg, indexReg));
+    insns.push(new Ldai(new Imm(1)));
+    insns.push(new Sta(indexReg));
+    insns.push(new Lda(cookedArr));
+    insns.push(new Stobjbyvalue(new Imm(icSize + 3), objReg, indexReg));
+    insns.push(new Lda(objReg));
+    insns.push(new Gettemplateobject(new Imm(icSize + 5)));
+
+    let nextIc = icSize + 6;
+    return {insns: insns, nextIc: nextIc};
 
 }
 
@@ -89,7 +96,7 @@ describe("templateExpressionTest", function () {
         let insns = compileMainSnippet("`string text line 1`;");
         let expected = [
             new LdaStr("string text line 1"),
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -97,13 +104,15 @@ describe("templateExpressionTest", function () {
     it("`Fifteen is ${5 + 10}`", function () {
         let insns = compileMainSnippet("`Fifteen is ${5 + 10}`");
         let headVal = new VReg();
+        let insertedInsns = MicroCreateAddInsns(5, 10, 0).insns;
+        let followedIc = MicroCreateAddInsns(5, 10, 0).nextIc;
 
         let expected = [
             new LdaStr("Fifteen is "),
-            new StaDyn(headVal),
-            ...MicroCreateAddInsns(5, 10),
-            new EcmaAdd2dyn(headVal),
-            new EcmaReturnundefined()
+            new Sta(headVal),
+            ...insertedInsns,
+            new Add2(new Imm(followedIc), headVal),
+            new Returnundefined()
         ]
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -119,31 +128,36 @@ describe("templateExpressionTest", function () {
         let cookedArr1 = new VReg();
         let templateObj = new VReg();
 
-        let expected = [
+        let insertedInsns1 = MicroCreateObjAndPropInsns(0).insns;
+        let followedIc1 = MicroCreateObjAndPropInsns(0).nextIc;
 
-            ...MicroCreateObjAndPropInsns(),
-            new EcmaCreateemptyarray(),
-            new StaDyn(rawArr),
-            new EcmaCreateemptyarray(),
-            new StaDyn(cookedArr),
-
-            new LdaiDyn(new Imm(0)),
-            new StaDyn(elemIdxReg),
+        let insertedInsns2 = MicroGetTemplateObject(rawArr1, cookedArr, followedIc1 + 6).insns;
+        let followedIc2 = MicroGetTemplateObject(rawArr1, cookedArr, followedIc1 + 6).nextIc;
+        let expected = [
+            ...insertedInsns1,
+            new Createemptyarray(new Imm(followedIc1)),
+            new Sta(rawArr),
+            new Createemptyarray(new Imm(followedIc1 + 1)),
+            new Sta(cookedArr),
+
+            new Ldai(new Imm(0)),
+            new Sta(elemIdxReg),
             new LdaStr("string text line 1"),
-            new EcmaStobjbyvalue(rawArr, elemIdxReg),
+            new Stobjbyvalue(new Imm(followedIc1 + 2), rawArr, elemIdxReg),
 
             new LdaStr("string text line 1"),
-            new EcmaStobjbyvalue(cookedArr, elemIdxReg),
-            new MovDyn(rawArr1, rawArr),
-            new MovDyn(cookedArr1, cookedArr),
+            new Stobjbyvalue(new Imm(followedIc1 + 4), cookedArr, elemIdxReg),
+            new Mov(rawArr1, rawArr),
+            new Mov(cookedArr1, cookedArr),
 
-            ...MicroGetTemplateObject(rawArr1, cookedArr),
-            new StaDyn(templateObj),
+            ...insertedInsns2,
+            new Sta(templateObj),
 
-            // structure call 
-            new EcmaCallithisrangedyn(new Imm(2), [prop, obj, templateObj]),
+            // structure call
+            new Lda(prop),
+            new Callthisrange(new Imm(followedIc2), new Imm(1), [obj, templateObj]),
 
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -160,31 +174,35 @@ describe("templateExpressionTest", function () {
         let cookedArr1 = new VReg();
         let templateObj = new VReg();
 
+        let insertedInsns1 = MicroCreateObjAndPropInsns(0).insns;
+        let followedIc1 = MicroCreateObjAndPropInsns(0).nextIc;
+        let insertedInsns2 = MicroGetTemplateObject(rawArr1, cookedArr1, followedIc1 + 6).insns;
+        let followedIc2 = MicroGetTemplateObject(rawArr1, cookedArr1, followedIc1 + 6).nextIc;
         let expected = [
-
-            ...MicroCreateObjAndPropInsns(),
-            new EcmaCreateemptyarray(),
-            new StaDyn(rawArr),
-            new EcmaCreateemptyarray(),
-            new StaDyn(cookedArr),
-
-            new LdaiDyn(new Imm(0)),
-            new StaDyn(elemIdxReg),
+            ...insertedInsns1,
+            new Createemptyarray(new Imm(followedIc1)),
+            new Sta(rawArr),
+            new Createemptyarray(new Imm(followedIc1 + 1)),
+            new Sta(cookedArr),
+
+            new Ldai(new Imm(0)),
+            new Sta(elemIdxReg),
             new LdaStr("string text line 1\\nstring text line 2"),
-            new EcmaStobjbyvalue(rawArr, elemIdxReg),
+            new Stobjbyvalue(new Imm(followedIc1 + 2), rawArr, elemIdxReg),
 
             new LdaStr("string text line 1\nstring text line 2"),
-            new EcmaStobjbyvalue(cookedArr, elemIdxReg),
-            new MovDyn(rawArr1, rawArr),
-            new MovDyn(cookedArr1, cookedArr),
+            new Stobjbyvalue(new Imm(followedIc1 + 4), cookedArr, elemIdxReg),
+            new Mov(rawArr1, rawArr),
+            new Mov(cookedArr1, cookedArr),
 
-            ...MicroGetTemplateObject(rawArr1, cookedArr1),
-            new StaDyn(templateObj),
+            ...insertedInsns2,
+            new Sta(templateObj),
 
-            // structure call 
-            new EcmaCallithisrangedyn(new Imm(2), [prop, obj, templateObj]),
+            // structure call
+            new Lda(prop),
+            new Callthisrange(new Imm(followedIc2), new Imm(1), [obj, templateObj]),
 
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -202,38 +220,44 @@ describe("templateExpressionTest", function () {
         let addRet = new VReg();
         let templateObj = new VReg();
 
+        let insertedInsns1 = MicroCreateObjAndPropInsns(0).insns;
+        let followedIc1 = MicroCreateObjAndPropInsns(0).nextIc;
+        let insertedInsns2 = MicroGetTemplateObject(rawArr1, cookedArr1, followedIc1 + 10).insns;
+        let followedIc2 = MicroGetTemplateObject(rawArr1, cookedArr1, followedIc1 + 10).nextIc;
+        let insertedInsns3 = MicroCreateAddInsns(5, 10, followedIc2).insns;
+        let followedIc3 = MicroCreateAddInsns(5, 10, followedIc2).nextIc;
         let expected = [
-
-            ...MicroCreateObjAndPropInsns(),
-            new EcmaCreateemptyarray(),
-            new StaDyn(rawArr),
-            new EcmaCreateemptyarray(),
-            new StaDyn(cookedArr),
-
-            new LdaiDyn(new Imm(0)),
-            new StaDyn(elemIdxReg),
+            ...insertedInsns1,
+            new Createemptyarray(new Imm(followedIc1)),
+            new Sta(rawArr),
+            new Createemptyarray(new Imm(followedIc1 + 1)),
+            new Sta(cookedArr),
+
+            new Ldai(new Imm(0)),
+            new Sta(elemIdxReg),
             new LdaStr("Fifteen is "),
-            new EcmaStobjbyvalue(rawArr, elemIdxReg),
+            new Stobjbyvalue(new Imm(followedIc1 + 2), rawArr, elemIdxReg),
             new LdaStr("Fifteen is "),
-            new EcmaStobjbyvalue(cookedArr, elemIdxReg),
-            new LdaiDyn(new Imm(1)),
-            new StaDyn(elemIdxReg),
+            new Stobjbyvalue(new Imm(followedIc1 + 4), cookedArr, elemIdxReg),
+            new Ldai(new Imm(1)),
+            new Sta(elemIdxReg),
             new LdaStr(" !!"),
-            new EcmaStobjbyvalue(rawArr, elemIdxReg),
+            new Stobjbyvalue(new Imm(followedIc1 + 6), rawArr, elemIdxReg),
             new LdaStr(" !!"),
-            new EcmaStobjbyvalue(cookedArr, elemIdxReg),
-            new MovDyn(rawArr1, rawArr),
-            new MovDyn(cookedArr1, cookedArr),
+            new Stobjbyvalue(new Imm(followedIc1 + 8), cookedArr, elemIdxReg),
+            new Mov(rawArr1, rawArr),
+            new Mov(cookedArr1, cookedArr),
 
-            ...MicroGetTemplateObject(rawArr1, cookedArr1),
-            new StaDyn(templateObj),
+            ...insertedInsns2,
+            new Sta(templateObj),
 
-            ...MicroCreateAddInsns(5, 10),
-            new StaDyn(addRet),
+            ...insertedInsns3,
+            new Sta(addRet),
 
             // structure call
-            new EcmaCallithisrangedyn(new Imm(3), [prop, obj, rawArr, templateObj]),
-            new EcmaReturnundefined()
+            new Lda(prop),
+            new Callthisrange(new Imm(followedIc3), new Imm(2), [obj, rawArr, templateObj]),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -241,7 +265,6 @@ describe("templateExpressionTest", function () {
     it("String.raw`Fifteen is ${5 + 10} !!\\n Is not ${15 + 10} !!!`", function () {
         let insns = compileMainSnippet("String.raw`Fifteen is ${5 + 10} !!\\n Is not ${15 + 10} !!!\\n`");
         let obj = new VReg();
-        let val = new VReg();
         let prop = new VReg();
         let elemIdxReg = new VReg();
         let rawArr = new VReg();
@@ -252,46 +275,56 @@ describe("templateExpressionTest", function () {
         let addRet2 = new VReg();
         let templateObj = new VReg();
 
+        let insertedInsns1 = MicroCreateObjAndPropInsns(0).insns;
+        let followedIc1 = MicroCreateObjAndPropInsns(0).nextIc;
+        let insertedInsns2 = MicroGetTemplateObject(rawArr1, cookedArr1, followedIc1 + 14).insns;
+        let followedIc2 = MicroGetTemplateObject(rawArr1, cookedArr1, followedIc1 + 14).nextIc;
+        let insertedInsns3 = MicroCreateAddInsns(5, 10, followedIc2).insns;
+        let followedIc3 = MicroCreateAddInsns(5, 10, followedIc2).nextIc;
+        let insertedInsns4 = MicroCreateAddInsns(15, 10, followedIc3).insns;
+        let followedIc4 = MicroCreateAddInsns(15, 10, followedIc3).nextIc;
+
         let expected = [
 
-            ...MicroCreateObjAndPropInsns(),
-            new EcmaCreateemptyarray(),
-            new StaDyn(rawArr),
-            new EcmaCreateemptyarray(),
-            new StaDyn(cookedArr),
+            ...insertedInsns1,
+            new Createemptyarray(new Imm(followedIc1)),
+            new Sta(rawArr),
+            new Createemptyarray(new Imm(followedIc1 + 1)),
+            new Sta(cookedArr),
 
-            new LdaiDyn(new Imm(0)),
-            new StaDyn(elemIdxReg),
+            new Ldai(new Imm(0)),
+            new Sta(elemIdxReg),
             new LdaStr("Fifteen is "),
-            new EcmaStobjbyvalue(rawArr, elemIdxReg),
+            new Stobjbyvalue(new Imm(followedIc1 + 2), rawArr, elemIdxReg),
             new LdaStr("Fifteen is "),
-            new EcmaStobjbyvalue(cookedArr, elemIdxReg),
-            new LdaiDyn(new Imm(1)),
-            new StaDyn(elemIdxReg),
+            new Stobjbyvalue(new Imm(followedIc1 + 4), cookedArr, elemIdxReg),
+            new Ldai(new Imm(1)),
+            new Sta(elemIdxReg),
             new LdaStr(" !!\\n Is not "),
-            new EcmaStobjbyvalue(rawArr, elemIdxReg),
+            new Stobjbyvalue(new Imm(followedIc1 + 6), rawArr, elemIdxReg),
             new LdaStr(" !!\n Is not "),
-            new EcmaStobjbyvalue(cookedArr, elemIdxReg),
-            new LdaiDyn(new Imm(2)),
-            new StaDyn(elemIdxReg),
+            new Stobjbyvalue(new Imm(followedIc1 + 8), cookedArr, elemIdxReg),
+            new Ldai(new Imm(2)),
+            new Sta(elemIdxReg),
             new LdaStr(" !!!\\n"),
-            new EcmaStobjbyvalue(rawArr, elemIdxReg),
+            new Stobjbyvalue(new Imm(followedIc1 + 10), rawArr, elemIdxReg),
             new LdaStr(" !!!\n"),
-            new EcmaStobjbyvalue(cookedArr, elemIdxReg),
-            new MovDyn(rawArr1, rawArr),
-            new MovDyn(cookedArr1, cookedArr),
+            new Stobjbyvalue(new Imm(followedIc1 + 12), cookedArr, elemIdxReg),
+            new Mov(rawArr1, rawArr),
+            new Mov(cookedArr1, cookedArr),
 
-            ...MicroGetTemplateObject(rawArr1, cookedArr1),
-            new StaDyn(templateObj),
+            ...insertedInsns2,
+            new Sta(templateObj),
 
-            ...MicroCreateAddInsns(5, 10),
-            new StaDyn(addRet1),
-            ...MicroCreateAddInsns(15, 10),
-            new StaDyn(addRet2),
+            ...insertedInsns3,
+            new Sta(addRet1),
+            ...insertedInsns4,
+            new Sta(addRet2),
 
             // structure call
-            new EcmaCallithisrangedyn(new Imm(4), [prop, obj, rawArr, cookedArr, templateObj]),
-            new EcmaReturnundefined()
+            new Lda(prop),
+            new Callthisrange(new Imm(followedIc4), new Imm(3), [obj, rawArr, cookedArr, templateObj]),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/expression/thisKeyWord.test.ts b/ts2panda/tests/expression/thisKeyWord.test.ts
index e88f39146dfb25e0de7fda3e1120a23536077968..616e57e07193ecef9b6c8daec9a8d7588966fa1f 100644
--- a/ts2panda/tests/expression/thisKeyWord.test.ts
+++ b/ts2panda/tests/expression/thisKeyWord.test.ts
@@ -18,8 +18,8 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaReturnundefined,
-    LdaDyn,
+    Returnundefined,
+    Lda,
     VReg
 } from "../../src/irnodes";
 import { PandaGen } from "../../src/pandagen";
@@ -39,8 +39,8 @@ describe("ThisKeyword", function () {
         let globalScope = snippetCompiler.getGlobalScope();
         let insns = snippetCompiler.getGlobalInsns();
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
         let thisVar = globalScope!.findLocal("this");
@@ -54,8 +54,8 @@ describe("ThisKeyword", function () {
         let functionScope = functionPg!.getScope();
         let insns = compileMainSnippet("this;", pandaGen, functionScope);
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
         let thisVar = functionScope!.findLocal("this");
diff --git a/ts2panda/tests/expression/typeOf.test.ts b/ts2panda/tests/expression/typeOf.test.ts
index e3735dfb5b654167aacef5804e733e56b7e37945..35353c02fd60c90441b650d8f9c976441e81ae40 100644
--- a/ts2panda/tests/expression/typeOf.test.ts
+++ b/ts2panda/tests/expression/typeOf.test.ts
@@ -18,17 +18,17 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaCallarg1dyn,
-    EcmaLdobjbyname,
-    EcmaReturnundefined,
-    EcmaTryldglobalbyname,
-    EcmaTypeofdyn,
+    Callarg1,
+    Ldobjbyname,
+    Returnundefined,
+    Tryldglobalbyname,
+    Typeof,
     Imm,
-    LdaiDyn,
+    Ldai,
     LdaStr,
-    ResultType,
-    StaDyn,
-    VReg
+    Sta,
+    VReg,
+    Lda
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
 
@@ -36,9 +36,9 @@ describe("TypeOfTest", function () {
     it("typeof 12", function () {
         let insns = compileMainSnippet("typeof 5");
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaTypeofdyn(),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Typeof(new Imm(0)),
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -49,14 +49,15 @@ describe("TypeOfTest", function () {
         let arg1 = new VReg();
         let arg3 = new VReg();
         let expected = [
-            new EcmaTryldglobalbyname("Number"),
-            new StaDyn(arg1),
+            new Tryldglobalbyname(new Imm(0), "Number"),
+            new Sta(arg1),
 
             new LdaStr("5"),
-            new StaDyn(arg3),
-            new EcmaCallarg1dyn(arg1, arg3),
-            new EcmaTypeofdyn(),
-            new EcmaReturnundefined()
+            new Sta(arg3),
+            new Lda(arg1),
+            new Callarg1(new Imm(1), arg3),
+            new Typeof(new Imm(2)),
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -66,9 +67,10 @@ describe("TypeOfTest", function () {
         let insns = compileMainSnippet("typeof x");
 
         let expected = [
-            new EcmaLdobjbyname("x", new VReg()),
-            new EcmaTypeofdyn(),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), "x"),
+            new Typeof(new Imm(2)),
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -78,9 +80,10 @@ describe("TypeOfTest", function () {
         let insns = compileMainSnippet("typeof(x)");
 
         let expected = [
-            new EcmaLdobjbyname("x", new VReg()),
-            new EcmaTypeofdyn(),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), "x"),
+            new Typeof(new Imm(2)),
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
diff --git a/ts2panda/tests/expression/void.test.ts b/ts2panda/tests/expression/void.test.ts
index 330849f16c42c742af3546c64df57037520de317..b8358ec7bf0496e2dfb166ad654666865d8d7cc4 100644
--- a/ts2panda/tests/expression/void.test.ts
+++ b/ts2panda/tests/expression/void.test.ts
@@ -18,11 +18,12 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaReturnundefined,
-    EcmaStlettoglobalrecord,
-    EcmaTryldglobalbyname,
-    LdaDyn,
-    VReg
+    Returnundefined,
+    Sttoglobalrecord,
+    Tryldglobalbyname,
+    Lda,
+    VReg,
+    Imm
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
 
@@ -31,11 +32,11 @@ describe("voidExpressionTest", function () {
         let insns = compileMainSnippet("let a; void (a);");
 
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaStlettoglobalrecord('a'),
-            new EcmaTryldglobalbyname('a'),
-            new LdaDyn(new VReg()),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Lda(new VReg()),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/hoist.test.ts b/ts2panda/tests/hoist.test.ts
index ffd5a7fe4d822ceccdab35b81498a5b26f4d626d..fc3e5cc5554436c32646766c31516cb3c0470866 100644
--- a/ts2panda/tests/hoist.test.ts
+++ b/ts2panda/tests/hoist.test.ts
@@ -18,19 +18,18 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaDefinefuncdyn,
-    EcmaIstrue,
-    EcmaReturnundefined,
-    EcmaStglobalvar,
-    EcmaThrowundefinedifhole,
+    Definefunc,
+    Istrue,
+    Returnundefined,
+    Stglobalvar,
+    ThrowUndefinedifhole,
     Imm,
     Jeqz,
     Label,
-    LdaDyn,
-    LdaiDyn,
+    Lda,
+    Ldai,
     LdaStr,
-    ResultType,
-    StaDyn,
+    Sta,
     VReg
 } from "../src/irnodes";
 import { checkInstructions, compileMainSnippet, SnippetCompiler } from "./utils/base";
@@ -41,11 +40,11 @@ describe("HoistTest", function () {
     it('case 1;', function () {
         let insns = compileMainSnippet("var a = 1;");
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaStglobalvar("a"),
-            new LdaiDyn(new Imm(1)),
-            new EcmaStglobalvar("a"),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Stglobalvar(new Imm(0), "a"),
+            new Ldai(new Imm(1)),
+            new Stglobalvar(new Imm(1), "a"),
+            new Returnundefined()
         ]
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -59,15 +58,15 @@ describe("HoistTest", function () {
         let endLabel = new Label();
 
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaStglobalvar("a"),
-            new LdaDyn(new VReg()),
-            new EcmaIstrue(),
+            new Lda(new VReg()),
+            new Stglobalvar(new Imm(0), "a"),
+            new Lda(new VReg()),
+            new Istrue(),
             new Jeqz(endLabel),
-            new LdaiDyn(new Imm(2)),
-            new EcmaStglobalvar("a"),
+            new Ldai(new Imm(2)),
+            new Stglobalvar(new Imm(1), "a"),
             endLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ]
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -79,9 +78,9 @@ describe("HoistTest", function () {
 
         let insns = snippetCompiler.getGlobalInsns();
         let expected = [
-            new EcmaDefinefuncdyn("a", new Imm(0), new VReg()),
-            new EcmaStglobalvar("a"),
-            new EcmaReturnundefined()
+            new Definefunc(new Imm(0), "a", new Imm(0)),
+            new Stglobalvar(new Imm(1), "a"),
+            new Returnundefined()
         ]
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -93,9 +92,9 @@ describe("HoistTest", function () {
 
         let insns = snippetCompiler.getGlobalInsns();
         let expected = [
-            new EcmaDefinefuncdyn("#2#a", new Imm(0), new VReg()),
-            new EcmaStglobalvar("a"),
-            new EcmaReturnundefined()
+            new Definefunc(new Imm(0), "#2#a", new Imm(0)),
+            new Stglobalvar(new Imm(1), "a"),
+            new Returnundefined()
         ]
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -107,11 +106,11 @@ describe("HoistTest", function () {
         snippetCompiler.compile(`var a = 1; function a() {}`);
         let insns = snippetCompiler.getGlobalInsns();
         let expected = [
-            new EcmaDefinefuncdyn("a", new Imm(0), new VReg()),
-            new EcmaStglobalvar("a"),
-            new LdaiDyn(new Imm(1)),
-            new EcmaStglobalvar("a"),
-            new EcmaReturnundefined()
+            new Definefunc(new Imm(0), "a", new Imm(0)),
+            new Stglobalvar(new Imm(1), "a"),
+            new Ldai(new Imm(1)),
+            new Stglobalvar(new Imm(2), "a"),
+            new Returnundefined()
         ]
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -126,12 +125,12 @@ describe("HoistTest", function () {
 
         let a = new VReg();
         let expected = [
-            new LdaDyn(a),
-            new StaDyn(new VReg()),
-            new LdaiDyn(new Imm(1)),
-            new StaDyn(a),
+            new Lda(a),
+            new Sta(new VReg()),
+            new Ldai(new Imm(1)),
+            new Sta(a),
 
-            new EcmaReturnundefined()
+            new Returnundefined()
         ]
         expect(checkInstructions(insns!, expected)).to.be.true;
     });
@@ -144,10 +143,10 @@ describe("HoistTest", function () {
         let insns = funcPg!.getInsns();
         let a = new VReg();
         let expected = [
-            new EcmaDefinefuncdyn("b", new Imm(0), new VReg()),
-            new StaDyn(a),
+            new Definefunc(new Imm(0), "b", new Imm(0)),
+            new Sta(a),
 
-            new EcmaReturnundefined()
+            new Returnundefined()
         ]
 
         expect(checkInstructions(insns!, expected)).to.be.true;
@@ -163,8 +162,8 @@ describe("HoistTest", function () {
         let idReg = new VReg();
         let expected = [
             new LdaStr("a"),
-            new StaDyn(idReg),
-            new EcmaThrowundefinedifhole(new VReg(), idReg)
+            new Sta(idReg),
+            new ThrowUndefinedifhole(new VReg(), idReg)
         ]
 
         expect(checkInstructions(insns.slice(3, 5), expected));
@@ -183,8 +182,8 @@ describe("HoistTest", function () {
 
         let expected = [
             new LdaStr("a"),
-            new StaDyn(idReg),
-            new EcmaThrowundefinedifhole(new VReg(), idReg)
+            new Sta(idReg),
+            new ThrowUndefinedifhole(new VReg(), idReg)
         ]
 
         expect(checkInstructions(insns.slice(3, 5), expected));
@@ -203,8 +202,8 @@ describe("HoistTest", function () {
 
         let expected = [
             new LdaStr("a"),
-            new StaDyn(idReg),
-            new EcmaThrowundefinedifhole(new VReg(), idReg)
+            new Sta(idReg),
+            new ThrowUndefinedifhole(new VReg(), idReg)
         ]
 
         expect(checkInstructions(insns.slice(3, 5), expected));
diff --git a/ts2panda/tests/lexenv.test.ts b/ts2panda/tests/lexenv.test.ts
index a57433b157103c953a6fb68014569a1c92f53c64..1af583d013e45dde8d78e7a64ca08ec96cd38764 100644
--- a/ts2panda/tests/lexenv.test.ts
+++ b/ts2panda/tests/lexenv.test.ts
@@ -20,28 +20,26 @@ import {
     CompilerDriver
 } from "../src/compilerDriver";
 import {
-    EcmaAdd2dyn,
-    EcmaDefinefuncdyn,
-    EcmaIncdyn,
-    EcmaLdlexenvdyn,
-    EcmaLdlexvardyn,
-    EcmaNewlexenvdyn,
-    EcmaReturnundefined,
-    EcmaStglobalvar,
-    EcmaStlettoglobalrecord,
-    EcmaStlexvardyn,
-    EcmaThrowconstassignment,
-    EcmaThrowundefinedifhole,
-    EcmaTonumeric,
-    EcmaTrystglobalbyname,
+    Add2,
+    Definefunc,
+    Inc,
+    Ldlexvar,
+    Newlexenv,
+    Returnundefined,
+    Stglobalvar,
+    Sttoglobalrecord,
+    Stlexvar,
+    ThrowConstassignment,
+    ThrowUndefinedifhole,
+    Tonumeric,
+    Trystglobalbyname,
     Imm,
     IRNode,
-    LdaDyn,
-    LdaiDyn,
+    Lda,
+    Ldai,
     LdaStr,
-    ResultType,
-    ReturnDyn,
-    StaDyn,
+    Return,
+    Sta,
     VReg
 } from "../src/irnodes";
 import { PandaGen } from "../src/pandagen";
@@ -64,34 +62,23 @@ import {
     SnippetCompiler
 } from "./utils/base";
 
-function MicroCreateLexEnv(numVars: number, hasLexEnv: boolean): IRNode[] {
-    let insns = [];
-
-    if (hasLexEnv) {
-        insns.push(new EcmaNewlexenvdyn(new Imm(numVars)));
-    } else {
-        insns.push(new EcmaLdlexenvdyn());
-    }
-    insns.push(new StaDyn(new VReg())); // create lexenv
-
-    return insns;
-}
 
 function MicroStoreLexVar(level: number, slot: number, kind?: VarDeclarationKind, name?: string): IRNode[] {
     let insns = [];
 
     if (kind && name) {
-        insns.push(new EcmaLdlexvardyn(new Imm(level), new Imm(slot)));
-        insns.push(new StaDyn(new VReg()));
+        insns.push(new Ldlexvar(new Imm(level), new Imm(slot)));
+        insns.push(new Sta(new VReg()));
         insns.push(new LdaStr(name));
-        insns.push(new StaDyn(new VReg()));
-        insns.push(new EcmaThrowundefinedifhole(new VReg(), new VReg()));
+        insns.push(new Sta(new VReg()));
+        insns.push(new ThrowUndefinedifhole(new VReg(), new VReg()));
         if (kind == VarDeclarationKind.CONST) {
-            insns.push(new EcmaThrowconstassignment(new VReg()));
+            insns.push(new ThrowConstassignment(new VReg()));
         }
     }
-    insns.push(new EcmaStlexvardyn(new Imm(level), new Imm(slot), new VReg()));
-    insns.push(new LdaDyn(new VReg()));
+    insns.push(new Lda(new VReg()));
+    insns.push(new Stlexvar(new Imm(level), new Imm(slot)));
+    insns.push(new Lda(new VReg()));
 
     return insns;
 }
@@ -99,13 +86,13 @@ function MicroStoreLexVar(level: number, slot: number, kind?: VarDeclarationKind
 function MicroLoadLexVar(level: number, slot: number, kind?: VarDeclarationKind, name?: string): IRNode[] {
     let insns = [];
 
-    insns.push(new EcmaLdlexvardyn(new Imm(level), new Imm(slot)));
+    insns.push(new Ldlexvar(new Imm(level), new Imm(slot)));
     if (kind && name) {
-        insns.push(new StaDyn(new VReg()));
+        insns.push(new Sta(new VReg()));
         insns.push(new LdaStr(name));
-        insns.push(new StaDyn(new VReg()));
-        insns.push(new EcmaThrowundefinedifhole(new VReg(), new VReg()));
-        insns.push(new LdaDyn(new VReg()));
+        insns.push(new Sta(new VReg()));
+        insns.push(new ThrowUndefinedifhole(new VReg(), new VReg()));
+        insns.push(new Lda(new VReg()));
     }
 
     return insns;
@@ -303,7 +290,7 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
         // load local register to acc
         let outInsns = pandaGen.getInsns();
         let expected = [
-            new LdaDyn(varReg),
+            new Lda(varReg),
         ];
 
         expect(checkInstructions(outInsns, expected)).to.be.true;
@@ -325,12 +312,12 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
         let tempReg = new VReg();
         let nameReg = new VReg();
         let expected = [
-            new EcmaLdlexvardyn(new Imm(0), new Imm(0)),
-            new StaDyn(tempReg),
+            new Ldlexvar(new Imm(0), new Imm(0)),
+            new Sta(tempReg),
             new LdaStr("var1"),
-            new StaDyn(nameReg),
-            new EcmaThrowundefinedifhole(new VReg(), nameReg),
-            new LdaDyn(tempReg)
+            new Sta(nameReg),
+            new ThrowUndefinedifhole(new VReg(), nameReg),
+            new Lda(tempReg)
         ];
         expect(checkInstructions(outInsns, expected)).to.be.true;
     });
@@ -348,7 +335,7 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
         // load local register to acc
         let outInsns = pandaGen.getInsns();
         let expected = [
-            new StaDyn(varReg),
+            new Sta(varReg),
         ];
 
         expect(checkInstructions(outInsns, expected)).to.be.true;
@@ -370,9 +357,10 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
         let outInsns = pandaGen.getInsns();
         let valueReg = new VReg();
         let expected = [
-            new StaDyn(valueReg),
-            new EcmaStlexvardyn(new Imm(0), new Imm(0), valueReg),
-            new LdaDyn(new VReg())
+            new Sta(valueReg),
+            new Lda(valueReg),
+            new Stlexvar(new Imm(0), new Imm(0)),
+            new Lda(new VReg())
         ];
         expect(checkInstructions(outInsns, expected)).to.be.true;
     });
@@ -392,9 +380,10 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
         let outInsns = pandaGen.getInsns();
         let valueReg = new VReg();
         let expected = [
-            new StaDyn(valueReg),
-            new EcmaStlexvardyn(new Imm(0), new Imm(0), valueReg),
-            new LdaDyn(valueReg)
+            new Sta(valueReg),
+            new Lda(valueReg),
+            new Stlexvar(new Imm(0), new Imm(0)),
+            new Lda(valueReg)
         ];
         expect(checkInstructions(outInsns, expected)).to.be.true;
     });
@@ -410,18 +399,18 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
 
         let pandaGens = compileAllSnippet(source);
         let expected_main = [
-            new LdaDyn(new VReg()),
-            new EcmaStglobalvar("outer"),
-            new EcmaDefinefuncdyn("func", new Imm(0), new VReg()),
-            new EcmaStglobalvar("func"),
-            new LdaiDyn(new Imm(1)),
-            new EcmaStglobalvar("outer"),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Stglobalvar(new Imm(0), "outer"),
+            new Definefunc(new Imm(1), "func", new Imm(0)),
+            new Stglobalvar(new Imm(2), "func"),
+            new Ldai(new Imm(1)),
+            new Stglobalvar(new Imm(3), "outer"),
+            new Returnundefined()
         ];
         let expected_func = [
-            new LdaiDyn(new Imm(2)),
-            new EcmaStglobalvar("outer"),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(2)),
+            new Stglobalvar(new Imm(0), "outer"),
+            new Returnundefined()
         ];
 
         pandaGens.forEach((pg) => {
@@ -442,25 +431,21 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
       }
     `;
 
-        let insnsCreateLexEnv_main = MicroCreateLexEnv(1, false);
         let passes = [new CacheExpander()];
         let pandaGens = compileAllSnippet(source, passes);
         let expected_main = [
-            ...insnsCreateLexEnv_main,
-            new EcmaDefinefuncdyn("func", new Imm(0), new VReg()),
-            new EcmaStglobalvar("func"), // global.func = func_func_1
-            new LdaiDyn(new Imm(1)), // value = 1
-            // ...insnsStoreLexVar_main,
-            new EcmaStlettoglobalrecord("outer"),
-            new EcmaReturnundefined()
+            new Definefunc(new Imm(0), "func", new Imm(0)),
+            new Stglobalvar(new Imm(1), "func"), // global.func = func_func_1
+            new Ldai(new Imm(1)), // value = 1
+            new Sttoglobalrecord(new Imm(2), "outer"),
+            new Returnundefined()
         ];
-        let insnsCreateLexEnv_func = MicroCreateLexEnv(0, false);
+
         let expected_func = [
-            ...insnsCreateLexEnv_func,
-            new LdaiDyn(new Imm(2)),
+            new Ldai(new Imm(2)),
             // ...insnsStoreLexVar_func,
-            new EcmaTrystglobalbyname("outer"),
-            new EcmaReturnundefined()
+            new Trystglobalbyname(new Imm(0), "outer"),
+            new Returnundefined()
         ];
 
         pandaGens.forEach((pg) => {
@@ -493,42 +478,43 @@ describe("lexenv-compile-testcase in lexenv.test.ts", function () {
       func();
     `;
 
-        let insnsCreateLexEnv_outer = MicroCreateLexEnv(2, true);
         let insnsStoreLexVar_outer_1 = MicroStoreLexVar(0, 0);
         let insnsStoreLexVar_outer_2 = MicroStoreLexVar(0, 1);
 
         let expect_outer: IRNode[] = [
-            ...insnsCreateLexEnv_outer,
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
+            new Newlexenv(new Imm(2)),
+            new Lda(new VReg()),
+            new Sta(new VReg()),
             ...insnsStoreLexVar_outer_1,
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Sta(new VReg()),
             ...insnsStoreLexVar_outer_2,
-            new EcmaDefinefuncdyn("#1#", new Imm(0), new VReg()),
+            new Definefunc(new Imm(0), "#1#", new Imm(0)),
             // returnStatement
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new ReturnDyn()
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Return()
         ];
 
 
         let expect_anonymous = [
-            ...MicroCreateLexEnv(0, true),
+            new Newlexenv(new Imm(0)),
             ...MicroLoadLexVar(1, 0),
-            new StaDyn(new VReg()),
-            new EcmaIncdyn(new VReg()),
-            new StaDyn(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Inc(new Imm(0)),
+            new Sta(new VReg()),
             ...MicroStoreLexVar(1, 0),
-            new EcmaTonumeric(new VReg()), // this is redundant load varialbe
+            new Lda(new VReg()),
+            new Tonumeric(new Imm(1)), // this is redundant load varialbe
             ...MicroLoadLexVar(1, 0),
-            new StaDyn(new VReg),
+            new Sta(new VReg),
             ...MicroLoadLexVar(1, 1),
-            new EcmaAdd2dyn(new VReg()),
+            new Add2(new Imm(2), new VReg()),
             // returnStatement
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new ReturnDyn()
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Return()
         ];
 
         let passes = [new CacheExpander()];
diff --git a/ts2panda/tests/pandagen.test.ts b/ts2panda/tests/pandagen.test.ts
index 5fc849d38922d2bbad9861146a6af458c6d1e02d..c78ae00af44d3232428a801f53fa32988b5d93c4 100644
--- a/ts2panda/tests/pandagen.test.ts
+++ b/ts2panda/tests/pandagen.test.ts
@@ -19,7 +19,7 @@ import {
 import 'mocha';
 import * as ts from "typescript";
 import {
-    StaDyn,
+    Sta,
     VReg
 } from "../src/irnodes";
 import { PandaGen } from "../src/pandagen";
@@ -32,7 +32,7 @@ describe("PandaGenTest", function () {
         pandaGen.storeAccumulator(ts.createNode(0), vreg);
         let insns = pandaGen.getInsns();
         let expected = [
-            new StaDyn(vreg)
+            new Sta(vreg)
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/regAllocator.test.ts b/ts2panda/tests/regAllocator.test.ts
index 55fb074c0f676163bdce3d3db040f4a851406fac..483d2e22b9ab5d5c96600ecb92b30bd26fcce4fc 100644
--- a/ts2panda/tests/regAllocator.test.ts
+++ b/ts2panda/tests/regAllocator.test.ts
@@ -17,16 +17,15 @@ import { expect } from 'chai';
 import 'mocha';
 import * as ts from "typescript";
 import {
-    CallRange,
-    EcmaCallirangedyn,
-    EcmaReturnundefined,
-    EcmaStlettoglobalrecord,
-    EcmaTryldglobalbyname,
+    Callrange,
+    Returnundefined,
+    Sttoglobalrecord,
+    Tryldglobalbyname,
     Imm,
     IRNode,
-    LdaiDyn,
-    ResultType,
-    StaDyn,
+    Ldai,
+    Lda,
+    Sta,
     VReg
 } from "../src/irnodes";
 import { PandaGen } from "../src/pandagen";
@@ -67,16 +66,16 @@ describe("RegAllocator", function () {
         let insns = pgs[0].getInsns();
 
         let expected: IRNode[] = [
-            new LdaiDyn(new Imm(252)),
-            new EcmaStlettoglobalrecord('a252'),
-            new LdaiDyn(new Imm(253)),
-            new EcmaStlettoglobalrecord('a253'),
-            new LdaiDyn(new Imm(254)),
-            new EcmaStlettoglobalrecord('a254'),
-            new LdaiDyn(new Imm(255)),
-            new EcmaStlettoglobalrecord('a255'),
-            new EcmaTryldglobalbyname('a255'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(252)),
+            new Sttoglobalrecord(new Imm(0), 'a252'),
+            new Ldai(new Imm(253)),
+            new Sttoglobalrecord(new Imm(1), 'a253'),
+            new Ldai(new Imm(254)),
+            new Sttoglobalrecord(new Imm(2), 'a254'),
+            new Ldai(new Imm(255)),
+            new Sttoglobalrecord(new Imm(3), 'a255'),
+            new Tryldglobalbyname(new Imm(4), 'a255'),
+            new Returnundefined()
         ]
 
         expect(checkInstructions(insns.slice(insns.length - 10), expected, checkRegisterNumber)).to.be.true;
@@ -89,8 +88,8 @@ describe("RegAllocator", function () {
         expect(true).to.be.true;
     });
 
-    it("make spill for CalliDynRange", function () {
-        /* since the bitwidth for CalliDynRange source register is 16 now, we do not need to make spill at all.
+    it("make spill for CalliRange", function () {
+        /* since the bitwidth for CalliRange source register is 16 now, we do not need to make spill at all.
            but in case later 16 might be changed to 8, then spill operation will be needed in some cases. this testcase is designed
            for 8bits constraints.
         */
@@ -107,33 +106,33 @@ describe("RegAllocator", function () {
             v[i].num = i;
         }
         let expected = [
-            new LdaiDyn(new Imm(252)),
-            new EcmaStlettoglobalrecord('a252'),
-            new LdaiDyn(new Imm(253)),
-            new EcmaStlettoglobalrecord('a253'),
-            new LdaiDyn(new Imm(254)),
-            new EcmaStlettoglobalrecord('a254'),
-            new LdaiDyn(new Imm(255)),
-            new EcmaStlettoglobalrecord('a255'),
-            new EcmaTryldglobalbyname('call'),
-            new StaDyn(v[3]),
-            new EcmaTryldglobalbyname('a252'),
-            new StaDyn(v[4]),
-            new EcmaTryldglobalbyname('a253'),
-            new StaDyn(v[5]),
-            new EcmaTryldglobalbyname('a254'),
-            new StaDyn(v[6]),
-            new EcmaTryldglobalbyname('a255'),
-            new StaDyn(v[7]),
-            new EcmaCallirangedyn(new Imm(4), [v[3],v[4],v[5],v[6],v[7]]),
-            new EcmaReturnundefined(),
+            new Ldai(new Imm(252)),
+            new Sttoglobalrecord(new Imm(0), 'a252'),
+            new Ldai(new Imm(253)),
+            new Sttoglobalrecord(new Imm(1), 'a253'),
+            new Ldai(new Imm(254)),
+            new Sttoglobalrecord(new Imm(2), 'a254'),
+            new Ldai(new Imm(255)),
+            new Sttoglobalrecord(new Imm(3), 'a255'),
+            new Tryldglobalbyname(new Imm(4), 'call'),
+            new Sta(v[3]),
+            new Tryldglobalbyname(new Imm(5), 'a252'),
+            new Sta(v[4]),
+            new Tryldglobalbyname(new Imm(6), 'a253'),
+            new Sta(v[5]),
+            new Tryldglobalbyname(new Imm(7), 'a254'),
+            new Sta(v[6]),
+            new Tryldglobalbyname(new Imm(8), 'a255'),
+            new Sta(v[7]),
+            new Lda(v[3]),
+            new Callrange(new Imm(9), new Imm(3), [v[4],v[5],v[6],v[7]]),
+            new Returnundefined(),
         ];
         expect(checkInstructions(insns.slice(insns.length - 20), expected, checkRegisterNumber)).to.be.true;
     });
 
     it("VReg sequence of CalliDynRange is not continuous", function () {
         let pandaGen = new PandaGen('', undefined, 0);
-
         let para1 = pandaGen.getTemp();
         let para2 = pandaGen.getTemp();
         let para3 = pandaGen.getTemp();
@@ -156,12 +155,11 @@ describe("RegAllocator", function () {
 
     it("VReg sequence of DynRange is not continuous", function () {
         let pandaGen = new PandaGen('', undefined, 0);
-
         let para1 = pandaGen.getTemp();
         let para2 = pandaGen.getTemp();
         let para3 = pandaGen.getTemp();
 
-        pandaGen.getInsns().push(new CallRange('test', [para1, para2, para3]))
+        // pandaGen.getInsns().push(new Callrange('test', [para1, para2, para3]))
 
         pandaGen.freeTemps(para1, para3, para2);
 
diff --git a/ts2panda/tests/statements/debugger.test.ts b/ts2panda/tests/statements/debugger.test.ts
index 9cbe527f94c0f08baa120bd7ecb7da256dfd1155..40935df57f47c5a81604d3e74c6386545a714640 100644
--- a/ts2panda/tests/statements/debugger.test.ts
+++ b/ts2panda/tests/statements/debugger.test.ts
@@ -18,8 +18,8 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaDebugger,
-    EcmaReturnundefined
+    Debugger,
+    Returnundefined
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
 
@@ -27,8 +27,8 @@ describe("DebuggerTest", function () {
     it("debugger", function () {
         let insns = compileMainSnippet("debugger;");
         let expected = [
-            new EcmaDebugger(),
-            new EcmaReturnundefined()
+            new Debugger(),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/statements/doWhile.test.ts b/ts2panda/tests/statements/doWhile.test.ts
index ee7d6722fa805fbf9a18846bef814e81347ce11f..b3f2d036278c057e76cb831d7ee0f4c050f9930d 100644
--- a/ts2panda/tests/statements/doWhile.test.ts
+++ b/ts2panda/tests/statements/doWhile.test.ts
@@ -18,17 +18,17 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaLessdyn,
-    EcmaReturnundefined,
-    EcmaStlettoglobalrecord,
-    EcmaTryldglobalbyname,
-    EcmaTrystglobalbyname,
+    Less,
+    Returnundefined,
+    Sttoglobalrecord,
+    Tryldglobalbyname,
+    Trystglobalbyname,
     Imm,
     Jeqz,
     Jmp,
-    Label, LdaiDyn,
-    ResultType,
-    StaDyn,
+    Label,
+    Ldai,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
@@ -68,29 +68,28 @@ describe("DoWhileLoopTest", function () {
     it('doWhileLoopWithContinue', function () {
         let insns = compileMainSnippet("let a = 5;" +
             "do { a = 1; continue; } while (a < 1);");
-        let a = new VReg();
         let lhs = new VReg();
         let labelPre = new Label();
         let labelCond = new Label();
         let labelPost = new Label();
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('a'),
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
             // body
             labelPre,
-            new LdaiDyn(new Imm(1)),
-            new EcmaTrystglobalbyname('a'),
+            new Ldai(new Imm(1)),
+            new Trystglobalbyname(new Imm(1), 'a'),
             new Jmp(labelCond), // continue
             // condition
             labelCond,
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(1)),
-            new EcmaLessdyn(lhs),
+            new Tryldglobalbyname(new Imm(2), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(1)),
+            new Less(new Imm(3), lhs),
             new Jeqz(labelPost),
             new Jmp(labelPre),
             labelPost,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ]
 
         // check the instruction kinds are the same as we expect
@@ -104,29 +103,28 @@ describe("DoWhileLoopTest", function () {
     it('doWhileLoopWithBreak', function () {
         let insns = compileMainSnippet("let a = 5;" +
             "do { a = 1; break; } while (a < 1);");
-        let a = new VReg();
         let lhs = new VReg();
         let labelPre = new Label();
         let labelPost = new Label();
         let labelCond = new Label();
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('a'),
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
             //body
             labelPre,
-            new LdaiDyn(new Imm(1)),
-            new EcmaTrystglobalbyname('a'),
+            new Ldai(new Imm(1)),
+            new Trystglobalbyname(new Imm(1), 'a'),
             new Jmp(labelPost), // break
             // condition
             labelCond,
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(1)),
-            new EcmaLessdyn(lhs),
+            new Tryldglobalbyname(new Imm(2), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(1)),
+            new Less(new Imm(3), lhs),
             new Jeqz(labelPost),
             new Jmp(labelPre),
             labelPost,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ]
 
         // check the instruction kinds are the same as we expect
diff --git a/ts2panda/tests/statements/for.test.ts b/ts2panda/tests/statements/for.test.ts
index 47bfce8d474592af88a61a45ad9f402f01c0e100..202c5b318de430721bc73a5e54bd12048549adcf 100644
--- a/ts2panda/tests/statements/for.test.ts
+++ b/ts2panda/tests/statements/for.test.ts
@@ -18,18 +18,17 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaIncdyn,
-    EcmaLessdyn,
-    EcmaReturnundefined,
-    EcmaTonumeric,
+    Inc,
+    Less,
+    Returnundefined,
+    Tonumeric,
     Imm,
     Jeqz,
     Jmp,
     Label,
-    LdaDyn,
-    LdaiDyn,
-    ResultType,
-    StaDyn,
+    Lda,
+    Ldai,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
@@ -45,7 +44,7 @@ describe("ForLoopTest", function () {
             labelIncr,
             new Jmp(labelPre),
             labelPost,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         let jumps = insns.filter(item => item instanceof Jmp);
 
@@ -111,27 +110,28 @@ describe("ForLoopTest", function () {
         let labelIncr = new Label();
         let expected = [
             // initializer
-            new LdaiDyn(new Imm(0)),
-            new StaDyn(i),
+            new Ldai(new Imm(0)),
+            new Sta(i),
             labelPre,
             // condition
-            new LdaDyn(i),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(5)),
-            new EcmaLessdyn(lhs),
+            new Lda(i),
+            new Sta(lhs),
+            new Ldai(new Imm(5)),
+            new Less(new Imm(0), lhs),
             new Jeqz(labelPost),
             // body
             new Jmp(labelIncr), // continue
             labelIncr,
             // incrementor
-            new LdaDyn(i),
-            new StaDyn(operand),
-            new EcmaIncdyn(operand),
-            new StaDyn(i),
+            new Lda(i),
+            new Sta(operand),
+            new Lda(operand),
+            new Inc(new Imm(1)),
+            new Sta(i),
             // jump to the loop header
             new Jmp(new Label()),
             labelPost,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         // check the instruction kinds are the same as we expect
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -151,27 +151,28 @@ describe("ForLoopTest", function () {
         let labelIncr = new Label();
         let expected = [
             // initializer
-            new LdaiDyn(new Imm(0)),
-            new StaDyn(i),
+            new Ldai(new Imm(0)),
+            new Sta(i),
             labelPre,
             // condition
-            new LdaDyn(i),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(5)),
-            new EcmaLessdyn(lhs),
+            new Lda(i),
+            new Sta(lhs),
+            new Ldai(new Imm(5)),
+            new Less(new Imm(0), lhs),
             new Jeqz(labelPost),
             // body
             new Jmp(labelPost), // break
             // incrementor
             labelIncr,
-            new LdaDyn(i),
-            new StaDyn(operand),
-            new EcmaIncdyn(operand),
-            new StaDyn(i),
+            new Lda(i),
+            new Sta(operand),
+            new Lda(operand),
+            new Inc(new Imm(1)),
+            new Sta(i),
             // jump to the loop header
             new Jmp(labelPre),
             labelPost,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         // check the instruction kinds are the same as we expect
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -201,47 +202,50 @@ describe("LoopWithLabelTests", function () {
         let labelIncr1 = new Label();
         let expected = [
             // initializer
-            new LdaiDyn(new Imm(0.0)),
-            new StaDyn(i),
+            new Ldai(new Imm(0.0)),
+            new Sta(i),
             labelPre,
             // condition
-            new LdaDyn(i),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(5.0)),
-            new EcmaLessdyn(lhs),
+            new Lda(i),
+            new Sta(lhs),
+            new Ldai(new Imm(5.0)),
+            new Less(new Imm(0), lhs),
             new Jeqz(labelPost),
 
             // second for
-            new LdaiDyn(new Imm(0.0)),
-            new StaDyn(j),
+            new Ldai(new Imm(0.0)),
+            new Sta(j),
             labelPre1,
             // condition
-            new LdaDyn(j),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(6.0)),
-            new EcmaLessdyn(lhs),
+            new Lda(j),
+            new Sta(lhs),
+            new Ldai(new Imm(6.0)),
+            new Less(new Imm(1), lhs),
             new Jeqz(labelPost1),
             new Jmp(labelPost),
             labelIncr1,
             // incrementor
-            new LdaDyn(j),
-            new StaDyn(j),
-            new EcmaIncdyn(j),
-            new StaDyn(j),
-            new EcmaTonumeric(j),
+            new Lda(j),
+            new Sta(j),
+            new Lda(j),
+            new Inc(new Imm(2)),
+            new Sta(j),
+            new Lda(j),
+            new Tonumeric(new Imm(3)),
             // jump to the loop header
             new Jmp(labelPre1),
             labelPost1,
             labelIncr,
             // incrementor
-            new LdaDyn(i),
-            new StaDyn(i),
-            new EcmaIncdyn(i),
-            new StaDyn(i),
+            new Lda(i),
+            new Sta(i),
+            new Lda(i),
+            new Inc(new Imm(4)),
+            new Sta(i),
             // jump to the loop header
             new Jmp(labelPre),
             labelPost,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
 
         // check the instruction kinds are the same as we expect
@@ -272,47 +276,50 @@ describe("LoopWithLabelTests", function () {
         let labelIncr1 = new Label();
         let expected = [
             // initializer
-            new LdaiDyn(new Imm(0.0)),
-            new StaDyn(i),
+            new Ldai(new Imm(0.0)),
+            new Sta(i),
             labelPre,
             // condition
-            new LdaDyn(i),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(5.0)),
-            new EcmaLessdyn(lhs),
+            new Lda(i),
+            new Sta(lhs),
+            new Ldai(new Imm(5.0)),
+            new Less(new Imm(0), lhs),
             new Jeqz(labelPost),
 
             // second for
-            new LdaiDyn(new Imm(0.0)),
-            new StaDyn(j),
+            new Ldai(new Imm(0.0)),
+            new Sta(j),
             labelPre1,
             // condition
-            new LdaDyn(j),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(6.0)),
-            new EcmaLessdyn(lhs),
+            new Lda(j),
+            new Sta(lhs),
+            new Ldai(new Imm(6.0)),
+            new Less(new Imm(1), lhs),
             new Jeqz(labelPost1),
             new Jmp(labelIncr),
             labelIncr1,
             // incrementor
-            new LdaDyn(j),
-            new StaDyn(j),
-            new EcmaIncdyn(j),
-            new StaDyn(j),
-            new EcmaTonumeric(j),
+            new Lda(j),
+            new Sta(j),
+            new Lda(j),
+            new Inc(new Imm(2)),
+            new Sta(j),
+            new Lda(j),
+            new Tonumeric(new Imm(3)),
             // jump to the loop header
             new Jmp(labelPre1),
             labelPost1,
             labelIncr,
             // incrementor
-            new LdaDyn(i),
-            new StaDyn(i),
-            new EcmaIncdyn(i),
-            new StaDyn(i),
+            new Lda(i),
+            new Sta(i),
+            new Lda(i),
+            new Inc(new Imm(4)),
+            new Sta(i),
             // jump to the loop header
             new Jmp(labelPre),
             labelPost,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
 
         // check the instruction kinds are the same as we expect
diff --git a/ts2panda/tests/statements/forIn.test.ts b/ts2panda/tests/statements/forIn.test.ts
index 374f6c7b400e99914b0a990da06c6c39d3c939f6..fc7d4bc55073727f9eaea61e910a2b2f0c3f9534 100644
--- a/ts2panda/tests/statements/forIn.test.ts
+++ b/ts2panda/tests/statements/forIn.test.ts
@@ -19,19 +19,20 @@ import {
 import 'mocha';
 import { DiagnosticCode, DiagnosticError } from '../../src/diagnostic';
 import {
-    EcmaCreateemptyobject,
-    EcmaGetnextpropname,
-    EcmaGetpropiterator,
-    EcmaReturnundefined,
-    EcmaStrictnoteqdyn,
-    EcmaTryldglobalbyname,
-    EcmaTrystglobalbyname,
+    Createemptyobject,
+    Getnextpropname,
+    Getpropiterator,
+    Returnundefined,
+    Strictnoteq,
+    Tryldglobalbyname,
+    Trystglobalbyname,
     Jeqz,
     Jmp,
     Label,
-    LdaDyn,
-    StaDyn,
-    VReg
+    Lda,
+    Sta,
+    VReg,
+    Imm
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
 
@@ -47,22 +48,22 @@ describe("forInLoopTest", function () {
         let loopStartLabel = new Label();
         let loopEndLabel = new Label();
         let expected = [
-            new EcmaCreateemptyobject(),
-            new StaDyn(objInstance),
-            new EcmaGetpropiterator(),
-            new StaDyn(iterReg),
+            new Createemptyobject(),
+            new Sta(objInstance),
+            new Getpropiterator(),
+            new Sta(iterReg),
 
             loopStartLabel,
-            new EcmaGetnextpropname(iterReg),
-            new StaDyn(rhs),
-            new EcmaStrictnoteqdyn(temp),
+            new Getnextpropname(iterReg),
+            new Sta(rhs),
+            new Strictnoteq(new Imm(0), temp),
             new Jeqz(loopEndLabel),
-            new LdaDyn(rhs),
-            new StaDyn(prop),
+            new Lda(rhs),
+            new Sta(prop),
             new Jmp(loopStartLabel),
 
             loopEndLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
 
@@ -85,17 +86,17 @@ describe("forInLoopTest", function () {
         let loopStartLabel = new Label();
         let loopEndLabel = new Label();
         let expected = [
-            new EcmaTryldglobalbyname('obj'),
-            new EcmaGetpropiterator(),
-            new StaDyn(iterReg),
+            new Tryldglobalbyname(new Imm(0), 'obj'),
+            new Getpropiterator(),
+            new Sta(iterReg),
 
             loopStartLabel,
-            new EcmaGetnextpropname(iterReg),
-            new StaDyn(rhs),
-            new EcmaStrictnoteqdyn(temp),
+            new Getnextpropname(iterReg),
+            new Sta(rhs),
+            new Strictnoteq(new Imm(1), temp),
             new Jeqz(loopEndLabel),
-            new LdaDyn(rhs),
-            new EcmaTrystglobalbyname('prop'),
+            new Lda(rhs),
+            new Trystglobalbyname(new Imm(2), 'prop'),
             new Jmp(loopStartLabel),
 
             loopEndLabel,
@@ -121,23 +122,23 @@ describe("forInLoopTest", function () {
         let loopStartLabel = new Label();
         let loopEndLabel = new Label();
         let expected = [
-            new EcmaCreateemptyobject(),
-            new StaDyn(objInstance),
-            new EcmaGetpropiterator(),
-            new StaDyn(iterReg),
+            new Createemptyobject(),
+            new Sta(objInstance),
+            new Getpropiterator(),
+            new Sta(iterReg),
 
             loopStartLabel,
-            new EcmaGetnextpropname(iterReg),
-            new StaDyn(rhs),
-            new EcmaStrictnoteqdyn(temp),
+            new Getnextpropname(iterReg),
+            new Sta(rhs),
+            new Strictnoteq(new Imm(0), temp),
             new Jeqz(loopEndLabel),
-            new LdaDyn(rhs),
-            new StaDyn(prop),
+            new Lda(rhs),
+            new Sta(prop),
             new Jmp(loopStartLabel),
             new Jmp(loopStartLabel),
 
             loopEndLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
 
@@ -157,23 +158,23 @@ describe("forInLoopTest", function () {
         let loopStartLabel = new Label();
         let loopEndLabel = new Label();
         let expected = [
-            new EcmaCreateemptyobject(),
-            new StaDyn(objInstance),
-            new EcmaGetpropiterator(),
-            new StaDyn(iterReg),
+            new Createemptyobject(),
+            new Sta(objInstance),
+            new Getpropiterator(),
+            new Sta(iterReg),
 
             loopStartLabel,
-            new EcmaGetnextpropname(iterReg),
-            new StaDyn(rhs),
-            new EcmaStrictnoteqdyn(temp),
+            new Getnextpropname(iterReg),
+            new Sta(rhs),
+            new Strictnoteq(new Imm(0), temp),
             new Jeqz(loopEndLabel),
-            new LdaDyn(rhs),
-            new StaDyn(prop),
+            new Lda(rhs),
+            new Sta(prop),
             new Jmp(loopEndLabel),
             new Jmp(loopStartLabel),
 
             loopEndLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
 
diff --git a/ts2panda/tests/statements/forOf.test.ts b/ts2panda/tests/statements/forOf.test.ts
index 1895fd2f4db2b5d2c23a3b921ffc8ecbb74e1c93..4a54e21b099aaa60e45f3fcff00865bcf8e03d06 100644
--- a/ts2panda/tests/statements/forOf.test.ts
+++ b/ts2panda/tests/statements/forOf.test.ts
@@ -19,21 +19,21 @@ import {
 import 'mocha';
 import { DiagnosticCode, DiagnosticError } from '../../src/diagnostic';
 import {
-    EcmaCallithisrangedyn,
-    EcmaCreateemptyarray,
-    EcmaGetiterator,
-    EcmaIsfalse,
-    EcmaLdobjbyname,
-    EcmaReturnundefined,
-    EcmaStrictnoteqdyn,
-    EcmaThrowdyn,
-    EcmaThrowifnotobject,
+    Callthis0,
+    Createemptyarray,
+    Getiterator,
+    Isfalse,
+    Ldobjbyname,
+    Returnundefined,
+    Strictnoteq,
+    Throw,
+    ThrowIfnotobject,
     Imm,
     Jeqz,
     Jmp,
     Label,
-    LdaDyn, ResultType,
-    StaDyn,
+    Lda,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
@@ -59,54 +59,60 @@ describe("ForOfLoopTest", function () {
         let isDone = new Label();
 
         let expected = [
-            new EcmaCreateemptyarray(),
-            new StaDyn(arrInstance),
-            new EcmaGetiterator(),
-            new StaDyn(iterReg),
-            new EcmaLdobjbyname("next", iterReg),
-            new StaDyn(nextMethodReg),
+            new Createemptyarray(new Imm(0)),
+            new Sta(arrInstance),
+            new Getiterator(new Imm(1)),
+            new Sta(iterReg),
+            new Lda(iterReg),
+            new Ldobjbyname(new Imm(2), "next"),
+            new Sta(nextMethodReg),
 
-            new LdaDyn(new VReg()),
-            new StaDyn(done),
+            new Lda(new VReg()),
+            new Sta(done),
 
             tryBeginLabel,
-            new LdaDyn(trueReg),
-            new StaDyn(done),
+            new Lda(trueReg),
+            new Sta(done),
             loopStartLabel,
-            new EcmaCallithisrangedyn(new Imm(1), [nextMethodReg, iterReg]),
-            new StaDyn(resultObj),
-            new EcmaThrowifnotobject(resultObj),
-            new EcmaLdobjbyname("done", resultObj),
-            new EcmaIsfalse(),
+            new Lda(nextMethodReg),
+            new Callthis0(new Imm(4), iterReg),
+            new Sta(resultObj),
+            new ThrowIfnotobject(resultObj),
+            new Lda(resultObj),
+            new Ldobjbyname(new Imm(5), "done"),
+            new Isfalse(),
             new Jeqz(loopEndLabel),
-            new EcmaLdobjbyname("value", resultObj),
-            new StaDyn(value),
+            new Lda(resultObj),
+            new Ldobjbyname(new Imm(7), "value"),
+            new Sta(value),
 
-            new LdaDyn(new VReg()),
-            new StaDyn(done),
+            new Lda(new VReg()),
+            new Sta(done),
 
-            new LdaDyn(value),
-            new StaDyn(a),
+            new Lda(value),
+            new Sta(a),
             tryEndLabel,
 
             new Jmp(loopStartLabel),
 
             catchBeginLabel,
-            new StaDyn(exceptionVreg),
-            new LdaDyn(done),
-            new EcmaStrictnoteqdyn(trueReg),
+            new Sta(exceptionVreg),
+            new Lda(done),
+            new Strictnoteq(new Imm(9), trueReg),
             new Jeqz(isDone),
-            new EcmaLdobjbyname("return", iterReg),
-            new StaDyn(nextMethodReg),
-            new EcmaStrictnoteqdyn(new VReg()),
+            new Lda(iterReg),
+            new Ldobjbyname(new Imm(10), "return"),
+            new Sta(nextMethodReg),
+            new Strictnoteq(new Imm(12), new VReg()),
             new Jeqz(isDone),
-            new EcmaCallithisrangedyn(new Imm(1), [nextMethodReg, iterReg]),
+            new Lda(nextMethodReg),
+            new Callthis0(new Imm(13), iterReg),
             isDone,
-            new LdaDyn(exceptionVreg),
-            new EcmaThrowdyn(),
+            new Lda(exceptionVreg),
+            new Throw(),
 
             loopEndLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
 
@@ -137,34 +143,38 @@ describe("ForOfLoopTest", function () {
         let insertedtryEndLabel = new Label();
 
         let expected = [
-            new EcmaCreateemptyarray(),
-            new StaDyn(arrInstance),
-            new EcmaGetiterator(),
-            new StaDyn(iterReg),
-            new EcmaLdobjbyname("next", iterReg),
-            new StaDyn(nextMethodReg),
+            new Createemptyarray(new Imm(0)),
+            new Sta(arrInstance),
+            new Getiterator(new Imm(1)),
+            new Sta(iterReg),
+            new Lda(iterReg),
+            new Ldobjbyname(new Imm(2), "next"),
+            new Sta(nextMethodReg),
 
-            new LdaDyn(new VReg()),
-            new StaDyn(done),
+            new Lda(new VReg()),
+            new Sta(done),
 
             tryBeginLabel,
-            new LdaDyn(trueReg),
-            new StaDyn(done),
+            new Lda(trueReg),
+            new Sta(done),
             loopStartLabel,
-            new EcmaCallithisrangedyn(new Imm(1), [nextMethodReg, iterReg]),
-            new StaDyn(resultObj),
-            new EcmaThrowifnotobject(resultObj),
-            new EcmaLdobjbyname("done", resultObj),
-            new EcmaIsfalse(),
+            new Lda(nextMethodReg),
+            new Callthis0(new Imm(4), iterReg),
+            new Sta(resultObj),
+            new ThrowIfnotobject(resultObj),
+            new Lda(resultObj),
+            new Ldobjbyname(new Imm(5), "done"),
+            new Isfalse(),
             new Jeqz(loopEndLabel),
-            new EcmaLdobjbyname("value", resultObj),
-            new StaDyn(value),
+            new Lda(resultObj),
+            new Ldobjbyname(new Imm(7), "value"),
+            new Sta(value),
 
-            new LdaDyn(new VReg()),
-            new StaDyn(done),
+            new Lda(new VReg()),
+            new Sta(done),
 
-            new LdaDyn(value),
-            new StaDyn(a),
+            new Lda(value),
+            new Sta(a),
 
             insertedtryBeginLabel,
             insertedtryEndLabel,
@@ -175,21 +185,23 @@ describe("ForOfLoopTest", function () {
             new Jmp(loopStartLabel),
 
             catchBeginLabel,
-            new StaDyn(exceptionVreg),
-            new LdaDyn(done),
-            new EcmaStrictnoteqdyn(trueReg),
+            new Sta(exceptionVreg),
+            new Lda(done),
+            new Strictnoteq(new Imm(9), trueReg),
             new Jeqz(isDone),
-            new EcmaLdobjbyname("return", iterReg),
-            new StaDyn(nextMethodReg),
-            new EcmaStrictnoteqdyn(new VReg()),
+            new Lda(iterReg),
+            new Ldobjbyname(new Imm(10), "return"),
+            new Sta(nextMethodReg),
+            new Strictnoteq(new Imm(12), new VReg()),
             new Jeqz(isDone),
-            new EcmaCallithisrangedyn(new Imm(1), [nextMethodReg, iterReg]),
+            new Lda(nextMethodReg),
+            new Callthis0(new Imm(13), iterReg),
             isDone,
-            new LdaDyn(exceptionVreg),
-            new EcmaThrowdyn(),
+            new Lda(exceptionVreg),
+            new Throw(),
 
             loopEndLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
 
@@ -220,43 +232,49 @@ describe("ForOfLoopTest", function () {
         let insertedtryEndLabel = new Label();
 
         let expected = [
-            new EcmaCreateemptyarray(),
-            new StaDyn(arrInstance),
-            new EcmaGetiterator(),
-            new StaDyn(iterReg),
-            new EcmaLdobjbyname("next", iterReg),
-            new StaDyn(nextMethodReg),
+            new Createemptyarray(new Imm(0)),
+            new Sta(arrInstance),
+            new Getiterator(new Imm(1)),
+            new Sta(iterReg),
+            new Lda(iterReg),
+            new Ldobjbyname(new Imm(2), "next"),
+            new Sta(nextMethodReg),
 
-            new LdaDyn(new VReg()),
-            new StaDyn(done),
+            new Lda(new VReg()),
+            new Sta(done),
 
             tryBeginLabel,
-            new LdaDyn(trueReg),
-            new StaDyn(done),
+            new Lda(trueReg),
+            new Sta(done),
             loopStartLabel,
-            new EcmaCallithisrangedyn(new Imm(1), [nextMethodReg, iterReg]),
-            new StaDyn(resultObj),
-            new EcmaThrowifnotobject(resultObj),
-            new EcmaLdobjbyname("done", resultObj),
-            new EcmaIsfalse(),
+            new Lda(nextMethodReg),
+            new Callthis0(new Imm(4), iterReg),
+            new Sta(resultObj),
+            new ThrowIfnotobject(resultObj),
+            new Lda(resultObj),
+            new Ldobjbyname(new Imm(5), "done"),
+            new Isfalse(),
             new Jeqz(loopEndLabel),
-            new EcmaLdobjbyname("value", resultObj),
-            new StaDyn(value),
+            new Lda(resultObj),
+            new Ldobjbyname(new Imm(7), "value"),
+            new Sta(value),
 
-            new LdaDyn(new VReg()),
-            new StaDyn(done),
+            new Lda(new VReg()),
+            new Sta(done),
 
-            new LdaDyn(value),
-            new StaDyn(a),
+            new Lda(value),
+            new Sta(a),
 
             insertedtryBeginLabel,
-            new EcmaLdobjbyname("return", iterReg),
-            new StaDyn(nextMethodReg),
-            new EcmaStrictnoteqdyn(new VReg()), // undefined
+            new Lda(iterReg),
+            new Ldobjbyname(new Imm(9), "return"),
+            new Sta(nextMethodReg),
+            new Strictnoteq(new Imm(11), new VReg()), // undefined
             new Jeqz(noReturn),
-            new EcmaCallithisrangedyn(new Imm(1), [nextMethodReg, iterReg]),
-            new StaDyn(new VReg()),
-            new EcmaThrowifnotobject(new VReg()),
+            new Lda(nextMethodReg),
+            new Callthis0(new Imm(12), iterReg),
+            new Sta(new VReg()),
+            new ThrowIfnotobject(new VReg()),
             noReturn,
             insertedtryEndLabel,
             new Jmp(loopEndLabel),
@@ -266,21 +284,23 @@ describe("ForOfLoopTest", function () {
             new Jmp(loopStartLabel),
 
             catchBeginLabel,
-            new StaDyn(exceptionVreg),
-            new LdaDyn(done),
-            new EcmaStrictnoteqdyn(trueReg),
+            new Sta(exceptionVreg),
+            new Lda(done),
+            new Strictnoteq(new Imm(13), trueReg),
             new Jeqz(isDone),
-            new EcmaLdobjbyname("return", iterReg),
-            new StaDyn(nextMethodReg),
-            new EcmaStrictnoteqdyn(new VReg()),
+            new Lda(iterReg),
+            new Ldobjbyname(new Imm(14), "return"),
+            new Sta(nextMethodReg),
+            new Strictnoteq(new Imm(16), new VReg()),
             new Jeqz(isDone),
-            new EcmaCallithisrangedyn(new Imm(1), [nextMethodReg, iterReg]),
+            new Lda(nextMethodReg),
+            new Callthis0(new Imm(17), iterReg),
             isDone,
-            new LdaDyn(exceptionVreg),
-            new EcmaThrowdyn(),
+            new Lda(exceptionVreg),
+            new Throw(),
 
             loopEndLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
diff --git a/ts2panda/tests/statements/functionDeclaration.test.ts b/ts2panda/tests/statements/functionDeclaration.test.ts
index 3c9b990385ec31f6ff1adf5ed9a18856fb5ea513..22898aaaad8bc3bcca9bfcd217bdb438ecd0b3fb 100644
--- a/ts2panda/tests/statements/functionDeclaration.test.ts
+++ b/ts2panda/tests/statements/functionDeclaration.test.ts
@@ -18,19 +18,18 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaCopyrestargs,
-    EcmaDefinefuncdyn,
-    EcmaReturnundefined,
-    EcmaStglobalvar,
-    EcmaStlettoglobalrecord,
-    EcmaStricteqdyn,
+    Copyrestargs,
+    Definefunc,
+    Returnundefined,
+    Stglobalvar,
+    Sttoglobalrecord,
+    Stricteq,
     Imm,
     Jeqz,
     Label,
-    LdaDyn,
-    LdaiDyn,
-    ResultType,
-    StaDyn,
+    Lda,
+    Ldai,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import {
@@ -45,9 +44,9 @@ describe("FunctionDeclarationTest", function () {
         snippetCompiler.compile("function foo() {}");
         let funcName = "foo";
         let expected = [
-            new EcmaDefinefuncdyn(funcName, new Imm(0), new VReg()),
-            new EcmaStglobalvar(funcName),
-            new EcmaReturnundefined()
+            new Definefunc(new Imm(0), funcName, new Imm(0)),
+            new Stglobalvar(new Imm(1), funcName),
+            new Returnundefined()
         ];
         let insns = snippetCompiler.getGlobalInsns();
         let globalScope = snippetCompiler.getGlobalScope();
@@ -64,9 +63,9 @@ describe("FunctionDeclarationTest", function () {
       function foo() {}
       `);
         let expected = [
-            new EcmaDefinefuncdyn("#2#foo", new Imm(0), new VReg()),
-            new EcmaStglobalvar("foo"),
-            new EcmaReturnundefined()
+            new Definefunc(new Imm(0), "#2#foo", new Imm(0)),
+            new Stglobalvar(new Imm(1), "foo"),
+            new Returnundefined()
         ];
         let insns = snippetCompiler.getGlobalInsns();
         let globalScope = snippetCompiler.getGlobalScope();
@@ -81,10 +80,10 @@ describe("FunctionDeclarationTest", function () {
         snippetCompiler.compile(`function out() {function foo() {}}`);
         let funcReg = new VReg();
         let expected = [
-            new EcmaDefinefuncdyn("foo", new Imm(0), new VReg()),
-            new StaDyn(funcReg),
+            new Definefunc(new Imm(0), "foo", new Imm(0)),
+            new Sta(funcReg),
 
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         let functionPg = snippetCompiler.getPandaGenByName("out");
         let insns = functionPg!.getInsns();
@@ -103,9 +102,9 @@ describe("FunctionDeclarationTest", function () {
         snippetCompiler.compile("let foo = function() {}");
         let insns = snippetCompiler.getGlobalInsns();
         let expected = [
-            new EcmaDefinefuncdyn("foo", new Imm(0), new VReg()),
-            new EcmaStlettoglobalrecord("foo"),
-            new EcmaReturnundefined()
+            new Definefunc(new Imm(0), "foo", new Imm(0)),
+            new Sttoglobalrecord(new Imm(1), "foo"),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -117,19 +116,19 @@ describe("FunctionDeclarationTest", function () {
         let endLabel = new Label();
 
         let expected_main = [
-            new EcmaDefinefuncdyn("test", new Imm(1), new VReg()),
-            new EcmaStglobalvar("test"),
-            new EcmaReturnundefined()
+            new Definefunc(new Imm(0), "test", new Imm(1)),
+            new Stglobalvar(new Imm(1), "test"),
+            new Returnundefined()
         ];
         let expected_func = [
             // func_test_0
-            new LdaDyn(new VReg()),
-            new EcmaStricteqdyn(undefinedVReg),
+            new Lda(new VReg()),
+            new Stricteq(new Imm(0), undefinedVReg),
             new Jeqz(endLabel),
-            new LdaiDyn(new Imm(1)),
-            new StaDyn(value),
+            new Ldai(new Imm(1)),
+            new Sta(value),
             endLabel,
-            new EcmaReturnundefined(),
+            new Returnundefined(),
         ];
 
         compilerunit.forEach(element => {
@@ -153,9 +152,9 @@ describe("FunctionDeclarationTest", function () {
         let lastParam = new VReg();
         let expected_func = [
             // func_test_0
-            new EcmaCopyrestargs(idx),
-            new StaDyn(lastParam),
-            new EcmaReturnundefined(),
+            new Copyrestargs(idx),
+            new Sta(lastParam),
+            new Returnundefined(),
         ];
 
         let functionPg = snippetCompiler.getPandaGenByName("test");
diff --git a/ts2panda/tests/statements/return.test.ts b/ts2panda/tests/statements/return.test.ts
index 7528c8dffc7f7563c8cb206d207ba2482925b63a..f27735134aa9024e9e0a9640697fcf93b79c545f 100644
--- a/ts2panda/tests/statements/return.test.ts
+++ b/ts2panda/tests/statements/return.test.ts
@@ -17,12 +17,12 @@ import {
   expect
 } from 'chai';
 import 'mocha';
-import { EcmaReturnundefined } from "../../src/irnodes";
+import { Returnundefined } from "../../src/irnodes";
 import { compileMainSnippet } from "../utils/base";
 
 describe("ReturnStatementTest", function () {
   it('exitGlobalScope', function () {
     let insns = compileMainSnippet("var a;");
-    expect(insns[insns.length - 1] instanceof EcmaReturnundefined).to.be.true;
+    expect(insns[insns.length - 1] instanceof Returnundefined).to.be.true;
   });
 });
diff --git a/ts2panda/tests/statements/switch.test.ts b/ts2panda/tests/statements/switch.test.ts
index 858b4f5028f412069499a4b3b454f550b1a008cf..10c21cb96ae476c767a587553442d82a2b705086 100644
--- a/ts2panda/tests/statements/switch.test.ts
+++ b/ts2panda/tests/statements/switch.test.ts
@@ -18,17 +18,17 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaReturnundefined,
-    EcmaStlettoglobalrecord,
-    EcmaStrictnoteqdyn,
-    EcmaTryldglobalbyname,
+    Returnundefined,
+    Sttoglobalrecord,
+    Strictnoteq,
+    Tryldglobalbyname,
     Imm,
     Jeqz,
     Jmp,
     Jnez,
-    Label, LdaiDyn,
-    ResultType,
-    StaDyn,
+    Label,
+    Ldai,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
@@ -36,24 +36,23 @@ import { checkInstructions, compileMainSnippet } from "../utils/base";
 describe("switchTest", function () {
     it("single case", function () {
         let insns = compileMainSnippet("let a = 0; switch (a) {case 0 : ;}");
-        let a = new VReg();
         let rhs = new VReg();
         let caseLabel = new Label();
         let switchEndLabel = new Label();
         let expected = [
-            new LdaiDyn(new Imm(0)),
-            new EcmaStlettoglobalrecord('a'),
-            // switch body
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(rhs),
-            new LdaiDyn(new Imm(0)),
-            new EcmaStrictnoteqdyn(rhs),
+            new Ldai(new Imm(0)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
+            // switch bodynew Imm(0), 
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(rhs),
+            new Ldai(new Imm(0)),
+            new Strictnoteq(new Imm(2), rhs),
             new Jeqz(caseLabel),
             new Jmp(switchEndLabel),
             // switch cases
             caseLabel,
             switchEndLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
         expect((<Jnez>insns[6]).getTarget() === insns[8]).to.be.true;
@@ -73,16 +72,16 @@ describe("switchTest", function () {
         let defaultLabel = new Label();
         let switchEndLabel = new Label();
         let expected = [
-            new LdaiDyn(new Imm(0)),
-            new EcmaStlettoglobalrecord('a'),
+            new Ldai(new Imm(0)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
             // switch body
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(rhs),
-            new LdaiDyn(new Imm(0)),
-            new EcmaStrictnoteqdyn(rhs),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(rhs),
+            new Ldai(new Imm(0)),
+            new Strictnoteq(new Imm(2), rhs),
             new Jeqz(caseLabel_0),
-            new LdaiDyn(new Imm(1)),
-            new EcmaStrictnoteqdyn(rhs),
+            new Ldai(new Imm(1)),
+            new Strictnoteq(new Imm(3), rhs),
             new Jeqz(caseLabel_1),
             new Jmp(defaultLabel),
             // cases
@@ -91,7 +90,7 @@ describe("switchTest", function () {
             // default case
             defaultLabel,
             switchEndLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -109,16 +108,16 @@ describe("switchTest", function () {
         let defaultLabel = new Label();
         let switchEndLabel = new Label();
         let expected = [
-            new LdaiDyn(new Imm(0)),
-            new EcmaStlettoglobalrecord('a'),
+            new Ldai(new Imm(0)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
             // switch body
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(rhs),
-            new LdaiDyn(new Imm(0)),
-            new EcmaStrictnoteqdyn(rhs),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(rhs),
+            new Ldai(new Imm(0)),
+            new Strictnoteq(new Imm(2), rhs),
             new Jeqz(caseLabel_0),
-            new LdaiDyn(new Imm(1)),
-            new EcmaStrictnoteqdyn(rhs),
+            new Ldai(new Imm(1)),
+            new Strictnoteq(new Imm(3), rhs),
             new Jeqz(caseLabel_1),
             new Jmp(defaultLabel),
             // switch cases
@@ -128,7 +127,7 @@ describe("switchTest", function () {
             new Jmp(switchEndLabel),
             defaultLabel,
             switchEndLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -144,16 +143,16 @@ describe("switchTest", function () {
         let caseLabel_1 = new Label();
         let switchEndLabel = new Label();
         let expected = [
-            new LdaiDyn(new Imm(0)),
-            new EcmaStlettoglobalrecord('a'),
+            new Ldai(new Imm(0)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
             // switch body
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(rhs),
-            new LdaiDyn(new Imm(0)),
-            new EcmaStrictnoteqdyn(rhs),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(rhs),
+            new Ldai(new Imm(0)),
+            new Strictnoteq(new Imm(2), rhs),
             new Jeqz(caseLabel_0),
-            new LdaiDyn(new Imm(1)),
-            new EcmaStrictnoteqdyn(rhs),
+            new Ldai(new Imm(1)),
+            new Strictnoteq(new Imm(3), rhs),
             new Jeqz(caseLabel_1),
             new Jmp(switchEndLabel),
             // switch cases
@@ -162,7 +161,7 @@ describe("switchTest", function () {
             caseLabel_1,
             new Jmp(switchEndLabel),
             switchEndLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -180,16 +179,16 @@ describe("switchTest", function () {
         let defaultLabel = new Label();
         let switchEndLabel = new Label();
         let expected = [
-            new LdaiDyn(new Imm(0)),
-            new EcmaStlettoglobalrecord('a'),
+            new Ldai(new Imm(0)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
             // switch body
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(rhs),
-            new LdaiDyn(new Imm(0)),
-            new EcmaStrictnoteqdyn(rhs),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(rhs),
+            new Ldai(new Imm(0)),
+            new Strictnoteq(new Imm(2), rhs),
             new Jeqz(caseLabel_0),
-            new LdaiDyn(new Imm(1)),
-            new EcmaStrictnoteqdyn(rhs),
+            new Ldai(new Imm(1)),
+            new Strictnoteq(new Imm(3), rhs),
             new Jeqz(caseLabel_1),
             new Jmp(defaultLabel),
             // switch cases
@@ -199,7 +198,7 @@ describe("switchTest", function () {
             defaultLabel,
             caseLabel_1,
             switchEndLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
diff --git a/ts2panda/tests/statements/tryCatch.test.ts b/ts2panda/tests/statements/tryCatch.test.ts
index 3fd1d5199c04da034e472901ea6b932f67e7d886..7a612579f9ba27105d239e8cfce81889c1528693 100644
--- a/ts2panda/tests/statements/tryCatch.test.ts
+++ b/ts2panda/tests/statements/tryCatch.test.ts
@@ -18,17 +18,16 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaReturnundefined,
-    EcmaStlettoglobalrecord,
-    EcmaThrowdyn,
-    EcmaTrystglobalbyname,
+    Returnundefined,
+    Sttoglobalrecord,
+    Throw,
+    Trystglobalbyname,
     Imm,
     Jmp,
     Label,
-    LdaDyn,
-    LdaiDyn,
-    ResultType,
-    StaDyn,
+    Lda,
+    Ldai,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
@@ -45,18 +44,18 @@ describe("TryCatch", function () {
         let catchEndLabel = new Label();
 
         let expected = [
-            new LdaiDyn(new Imm(0)),
-            new EcmaStlettoglobalrecord('a'),
+            new Ldai(new Imm(0)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
             tryBeginLabel,
-            new LdaiDyn(new Imm(1)),
-            new EcmaTrystglobalbyname('a'),
+            new Ldai(new Imm(1)),
+            new Trystglobalbyname(new Imm(1), 'a'),
             tryEndLabel,
             new Jmp(catchEndLabel),
             catchBeginLabel,
-            new LdaiDyn(new Imm(2)),
-            new EcmaTrystglobalbyname('a'),
+            new Ldai(new Imm(2)),
+            new Trystglobalbyname(new Imm(2), 'a'),
             catchEndLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -74,19 +73,19 @@ describe("TryCatch", function () {
         let err = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(0)),
-            new EcmaStlettoglobalrecord('a'),
+            new Ldai(new Imm(0)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
             tryBeginLabel,
-            new LdaiDyn(new Imm(1)),
-            new EcmaTrystglobalbyname('a'),
+            new Ldai(new Imm(1)),
+            new Trystglobalbyname(new Imm(1), 'a'),
             tryEndLabel,
             new Jmp(catchEndLabel),
             catchBeginLabel,
-            new StaDyn(err),
-            new LdaiDyn(new Imm(2)),
-            new EcmaTrystglobalbyname('a'),
+            new Sta(err),
+            new Ldai(new Imm(2)),
+            new Trystglobalbyname(new Imm(2), 'a'),
             catchEndLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -104,23 +103,23 @@ describe("TryCatch", function () {
         let exceptionVreg = new VReg();
 
         let expected = [
-            new LdaiDyn(new Imm(0)),
-            new EcmaStlettoglobalrecord('a'),
+            new Ldai(new Imm(0)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
             tryBeginLabel,
-            new LdaiDyn(new Imm(1)),
-            new EcmaTrystglobalbyname('a'),
+            new Ldai(new Imm(1)),
+            new Trystglobalbyname(new Imm(1), 'a'),
             tryEndLabel,
-            new LdaiDyn(new Imm(3)),
-            new EcmaTrystglobalbyname('a'),
+            new Ldai(new Imm(3)),
+            new Trystglobalbyname(new Imm(2), 'a'),
             new Jmp(catchEndLabel),
             catchBeginLabel,
-            new StaDyn(exceptionVreg),
-            new LdaiDyn(new Imm(3)),
-            new EcmaTrystglobalbyname('a'),
-            new LdaDyn(exceptionVreg),
-            new EcmaThrowdyn(),
+            new Sta(exceptionVreg),
+            new Ldai(new Imm(3)),
+            new Trystglobalbyname(new Imm(3), 'a'),
+            new Lda(exceptionVreg),
+            new Throw(),
             catchEndLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -143,30 +142,30 @@ describe("TryCatch", function () {
         let catchEndLabel = new Label();
 
         let expected = [
-            new LdaiDyn(new Imm(0)),
-            new EcmaStlettoglobalrecord('a'),
+            new Ldai(new Imm(0)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
             tryBeginLabel,
             nestedTryBeginLabel,
-            new LdaiDyn(new Imm(1)),
-            new EcmaTrystglobalbyname('a'),
+            new Ldai(new Imm(1)),
+            new Trystglobalbyname(new Imm(1), 'a'),
             nestedTryEndLabel,
             new Jmp(tryEndLabel),
             nestedCatchBeginLabel,
-            new LdaiDyn(new Imm(2)),
-            new EcmaTrystglobalbyname('a'),
+            new Ldai(new Imm(2)),
+            new Trystglobalbyname(new Imm(2), 'a'),
             nestedCatchEndLabel,
             tryEndLabel,
-            new LdaiDyn(new Imm(3)),
-            new EcmaTrystglobalbyname('a'),
+            new Ldai(new Imm(3)),
+            new Trystglobalbyname(new Imm(3), 'a'),
             new Jmp(catchEndLabel),
             catchBeginLabel,
-            new StaDyn(exceptionVreg),
-            new LdaiDyn(new Imm(3)),
-            new EcmaTrystglobalbyname('a'),
-            new LdaDyn(exceptionVreg),
-            new EcmaThrowdyn(),
+            new Sta(exceptionVreg),
+            new Ldai(new Imm(3)),
+            new Trystglobalbyname(new Imm(4), 'a'),
+            new Lda(exceptionVreg),
+            new Throw(),
             catchEndLabel,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
diff --git a/ts2panda/tests/statements/variableDeclaration.test.ts b/ts2panda/tests/statements/variableDeclaration.test.ts
index 1ce753c2d0ea1ca9bec4aeab8046ad6fecf61a43..3d544357269cbe01e4cd134df500e1eec7db9594 100644
--- a/ts2panda/tests/statements/variableDeclaration.test.ts
+++ b/ts2panda/tests/statements/variableDeclaration.test.ts
@@ -19,15 +19,14 @@ import {
 import 'mocha';
 import { DiagnosticCode, DiagnosticError } from '../../src/diagnostic';
 import {
-    EcmaReturnundefined,
-    EcmaStconsttoglobalrecord,
-    EcmaStglobalvar,
-    EcmaStlettoglobalrecord,
+    Returnundefined,
+    Stconsttoglobalrecord,
+    Stglobalvar,
+    Sttoglobalrecord,
     Imm,
-    LdaDyn,
-    LdaiDyn,
-    ResultType,
-    StaDyn,
+    Lda,
+    Ldai,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import {
@@ -50,9 +49,9 @@ describe("VariableDeclarationTest", function () {
         let insns = snippetCompiler.getGlobalInsns();
 
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaStglobalvar("i"),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Stglobalvar(new Imm(0), "i"),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
         let v = globalScope.findLocal("i");
@@ -65,9 +64,9 @@ describe("VariableDeclarationTest", function () {
         let globalScope = <GlobalScope>snippetCompiler.getGlobalScope();
         let insns = snippetCompiler.getGlobalInsns();
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaStlettoglobalrecord('i'),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Sttoglobalrecord(new Imm(0), 'i'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
         let v = globalScope.findLocal("i");
@@ -80,9 +79,9 @@ describe("VariableDeclarationTest", function () {
         let globalScope = <GlobalScope>snippetCompiler.getGlobalScope();
         let insns = snippetCompiler.getGlobalInsns();
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStconsttoglobalrecord('i'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Stconsttoglobalrecord(new Imm(0), 'i'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
         let v = globalScope.findLocal("i");
@@ -95,11 +94,11 @@ describe("VariableDeclarationTest", function () {
         let globalScope = <GlobalScope>snippetCompiler.getGlobalScope();
         let insns = snippetCompiler.getGlobalInsns();
         let expected = [
-            new LdaDyn(new VReg()),
-            new EcmaStglobalvar("i"),
-            new LdaiDyn(new Imm(5)),
-            new EcmaStglobalvar("i"),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Stglobalvar(new Imm(0), "i"),
+            new Ldai(new Imm(5)),
+            new Stglobalvar(new Imm(1), "i"),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
         let v = globalScope.findLocal("i");
@@ -112,9 +111,9 @@ describe("VariableDeclarationTest", function () {
         let globalScope = <GlobalScope>snippetCompiler.getGlobalScope();
         let insns = snippetCompiler.getGlobalInsns();
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('i'),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'i'),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
         let v = globalScope.findLocal("i");
@@ -158,9 +157,9 @@ describe("VariableDeclarationTest", function () {
         let functionScope = <FunctionScope>funcPg!.getScope();
         let insns = funcPg!.getInsns();
         let expected = [
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -176,9 +175,9 @@ describe("VariableDeclarationTest", function () {
         let functionScope = <FunctionScope>funcPg!.getScope();
         let insns = funcPg!.getInsns();
         let expected = [
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
         let i = functionScope.findLocal("i");
@@ -192,9 +191,9 @@ describe("VariableDeclarationTest", function () {
         let functionScope = <FunctionScope>funcPg!.getScope();
         let insns = funcPg!.getInsns();
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new StaDyn(new VReg()),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sta(new VReg()),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
         let i = functionScope.findLocal("i");
@@ -209,9 +208,9 @@ describe("VariableDeclarationTest", function () {
         let insns = funcPg!.getInsns();
 
         let expected = [
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaReturnundefined()
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
         let i = localScope!.findLocal("i");
@@ -237,9 +236,9 @@ describe("VariableDeclarationTest", function () {
         let insns = snippetCompiler.getGlobalInsns();
         let scope = snippetCompiler.getGlobalScope();
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new StaDyn(new VReg()),
-            new EcmaReturnundefined()
+            new Ldai(new Imm(5)),
+            new Sta(new VReg()),
+            new Returnundefined()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
         let i = scope!.findLocal("i");
diff --git a/ts2panda/tests/statements/while.test.ts b/ts2panda/tests/statements/while.test.ts
index 468e568977a46d578647be2a1ddba19830e7374c..13ae12c5ff11432bad303276cdaf6b0f3dc6c4bd 100644
--- a/ts2panda/tests/statements/while.test.ts
+++ b/ts2panda/tests/statements/while.test.ts
@@ -18,22 +18,20 @@ import {
 } from 'chai';
 import 'mocha';
 import {
-    EcmaAdd2dyn,
-    EcmaIstrue,
-    EcmaLessdyn,
-    EcmaReturnundefined,
-    EcmaStlettoglobalrecord,
-    EcmaTryldglobalbyname,
-    EcmaTrystglobalbyname,
+    Add2,
+    Istrue,
+    Less,
+    Returnundefined,
+    Sttoglobalrecord,
+    Tryldglobalbyname,
+    Trystglobalbyname,
     Imm,
     Jeqz,
-    Jgez,
     Jmp,
     Label,
-    LdaDyn,
-    LdaiDyn,
-    ResultType,
-    StaDyn,
+    Lda,
+    Ldai,
+    Sta,
     VReg
 } from "../../src/irnodes";
 import { checkInstructions, compileMainSnippet } from "../utils/base";
@@ -45,12 +43,12 @@ describe("WhileLoopTest", function () {
         let labelPost = new Label();
         let expected = [
             labelPre,
-            new LdaDyn(new VReg()),
-            new EcmaIstrue(),
+            new Lda(new VReg()),
+            new Istrue(),
             new Jeqz(labelPost),
             new Jmp(labelPre),
             labelPost,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ];
 
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -64,18 +62,18 @@ describe("WhileLoopTest", function () {
         let expected = [
             loopBegin,
             // a + b
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new EcmaTryldglobalbyname('b'),
-            new EcmaAdd2dyn(lhs),
-            new EcmaIstrue(),
+            new Tryldglobalbyname(new Imm(0), 'a'),
+            new Sta(lhs),
+            new Tryldglobalbyname(new Imm(1), 'b'),
+            new Add2(new Imm(2), lhs),
+            new Istrue(),
             new Jeqz(loopEnd),
             // body
             new Jmp(loopBegin),
             loopEnd
         ];
 
-        insns = insns.slice(4, insns.length - 1); // skip let a, b and return.dyn
+        insns = insns.slice(4, insns.length - 1); // skip let a, b and return.
         expect(checkInstructions(insns, expected)).to.be.true;
     });
 
@@ -92,24 +90,24 @@ describe("WhileLoopTest", function () {
             loopBegin,
             // condition
             // compute lhs
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
+            new Tryldglobalbyname(new Imm(0), 'a'),
+            new Sta(lhs),
             // compute rhs
-            new LdaiDyn(new Imm(0)),
-            new EcmaLessdyn(lhs),
+            new Ldai(new Imm(0)),
+            new Less(new Imm(1), lhs),
             new Jeqz(loopEnd),
 
             // body
-            new LdaiDyn(new Imm(1)),
-            new EcmaTrystglobalbyname('a'),
+            new Ldai(new Imm(1)),
+            new Trystglobalbyname(new Imm(2), 'a'),
             new Jmp(loopBegin),
 
             loopEnd,
         ];
 
-        insns = insns.slice(2, insns.length - 1); // skip let a and return.dyn
+        insns = insns.slice(2, insns.length - 1); // skip let a and return.
         expect(checkInstructions(insns, expected)).to.be.true;
-        expect((<Jgez>insns[5]).getTarget() === insns[insns.length - 1]).to.be.true;
+        expect((<Jeqz>insns[5]).getTarget() === insns[insns.length - 1]).to.be.true;
         expect((<Jmp>insns[insns.length - 2]).getTarget() === insns[0]).to.be.true;
     });
 
@@ -120,22 +118,22 @@ describe("WhileLoopTest", function () {
         let labelPre = new Label();
         let labelPost = new Label();
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('a'),
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
             labelPre,
             // condition
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(1)),
-            new EcmaLessdyn(lhs),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(1)),
+            new Less(new Imm(2), lhs),
             new Jeqz(labelPost),
             //body
-            new LdaiDyn(new Imm(2)),
-            new EcmaTrystglobalbyname('a'),
+            new Ldai(new Imm(2)),
+            new Trystglobalbyname(new Imm(3), 'a'),
             new Jmp(labelPre), // continue
             new Jmp(labelPre),
             labelPost,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ]
         // check the instruction kinds are the same as we expect
         expect(checkInstructions(insns, expected)).to.be.true;
@@ -152,22 +150,22 @@ describe("WhileLoopTest", function () {
         let labelPre = new Label();
         let labelPost = new Label();
         let expected = [
-            new LdaiDyn(new Imm(5)),
-            new EcmaStlettoglobalrecord('a'),
+            new Ldai(new Imm(5)),
+            new Sttoglobalrecord(new Imm(0), 'a'),
             labelPre,
             // condition
-            new EcmaTryldglobalbyname('a'),
-            new StaDyn(lhs),
-            new LdaiDyn(new Imm(1)),
-            new EcmaLessdyn(lhs),
+            new Tryldglobalbyname(new Imm(1), 'a'),
+            new Sta(lhs),
+            new Ldai(new Imm(1)),
+            new Less(new Imm(2), lhs),
             new Jeqz(labelPost),
             //body
-            new LdaiDyn(new Imm(2)),
-            new EcmaTrystglobalbyname('a'),
+            new Ldai(new Imm(2)),
+            new Trystglobalbyname(new Imm(3), 'a'),
             new Jmp(labelPost), //break
             new Jmp(labelPre),
             labelPost,
-            new EcmaReturnundefined()
+            new Returnundefined()
         ]
         // check the instruction kinds are the same as we expect
         expect(checkInstructions(insns, expected)).to.be.true;
diff --git a/ts2panda/tests/watch_expression/addWatch.test.ts b/ts2panda/tests/watch_expression/addWatch.test.ts
index bb280802e898c0c6a15ac086a1f5579ad0cd93cc..e60c93e34a7ffe491f7fc05f9f035a2ec2a6d509 100644
--- a/ts2panda/tests/watch_expression/addWatch.test.ts
+++ b/ts2panda/tests/watch_expression/addWatch.test.ts
@@ -19,52 +19,51 @@ import {
 import 'mocha';
 import { CmdOptions } from '../../src/cmdOptions';
 import {
-    EcmaAdd2dyn,
-    EcmaAsyncfunctionawaituncaught,
-    EcmaAsyncfunctionenter,
-    EcmaAsyncfunctionreject,
-    EcmaAsyncfunctionresolve,
-    EcmaCallarg0dyn,
-    EcmaCallarg1dyn,
-    EcmaCallargs2dyn,
-    EcmaCreatearraywithbuffer,
-    EcmaCreateemptyarray,
-    EcmaCreategeneratorobj,
-    EcmaCreateiterresultobj,
-    EcmaCreateobjectwithbuffer,
-    EcmaCreateregexpwithliteral,
-    EcmaDecdyn,
-    EcmaDefineclasswithbuffer,
-    EcmaDefinefuncdyn,
-    EcmaEqdyn,
-    EcmaGetresumemode,
-    EcmaIstrue,
-    EcmaLdobjbyindex,
-    EcmaLdobjbyname,
-    EcmaNegdyn,
-    EcmaNewobjdynrange,
-    EcmaResumegenerator,
-    EcmaStownbyindex,
-    EcmaStricteqdyn,
-    EcmaSuspendgenerator,
-    EcmaThrowdyn,
-    EcmaTonumeric,
-    EcmaTypeofdyn,
-    FldaiDyn,
+    Add2,
+    Asyncfunctionawaituncaught,
+    Asyncfunctionenter,
+    Asyncfunctionreject,
+    Asyncfunctionresolve,
+    Callarg0,
+    Callarg1,
+    Callargs2,
+    Createarraywithbuffer,
+    Createemptyarray,
+    Creategeneratorobj,
+    Createiterresultobj,
+    Createobjectwithbuffer,
+    Createregexpwithliteral,
+    Dec,
+    Defineclasswithbuffer,
+    Definefunc,
+    Eq,
+    Getresumemode,
+    Istrue,
+    Ldobjbyindex,
+    Ldobjbyname,
+    Neg,
+    Newobjrange,
+    Resumegenerator,
+    Stownbyindex,
+    Stricteq,
+    Suspendgenerator,
+    Throw,
+    Tonumeric,
+    Typeof,
+    Fldai,
     Imm,
     Jeqz,
     Jmp,
     Label,
-    LdaDyn,
+    Lda,
     LdaStr,
-    LdaiDyn,
-    MovDyn,
-    ReturnDyn,
-    StaDyn,
+    Ldai,
+    Mov,
+    Return,
+    Sta,
     VReg
 } from "../../src/irnodes";
-import { LocalVariable } from "../../src/variable";
-import { checkInstructions, compileMainSnippet, compileAllSnippet, SnippetCompiler } from "../utils/base";
+import { checkInstructions, compileMainSnippet, compileAllSnippet } from "../utils/base";
 
 describe("WatchExpressions", function () {
     it("watch NumericLiteral", function () {
@@ -75,17 +74,20 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new FldaiDyn(new Imm(123.212)),
-            new StaDyn(new VReg()),
-            new EcmaNegdyn(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaLdobjbyname('debuggerSetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Fldai(new Imm(123.212)),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Neg(new Imm(0)),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(1), 'debuggerSetValue'),
+            new Sta(new VReg()),
             new LdaStr('a'),
-            new StaDyn(new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(3), new VReg(), new VReg()),
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -99,21 +101,25 @@ describe("WatchExpressions", function () {
 
         let expected = [
             new LdaStr('He is called '),
-            new StaDyn(new VReg()),
-            new EcmaLdobjbyname('debuggerSetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerSetValue'),
+            new Sta(new VReg()),
             new LdaStr('y'),
-            new StaDyn(new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(3), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('Johnny'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(5), new VReg(), new VReg()),
             new LdaStr(''),
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -126,15 +132,17 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaCreateregexpwithliteral('abc', new Imm(0)),
-            new StaDyn(new VReg()),
-            new EcmaLdobjbyname('debuggerSetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Createregexpwithliteral(new Imm(0), 'abc', new Imm(0)),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(1), 'debuggerSetValue'),
+            new Sta(new VReg()),
             new LdaStr('a'),
-            new StaDyn(new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(3), new VReg(), new VReg()),
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -147,14 +155,16 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('_awef'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -169,23 +179,25 @@ describe("WatchExpressions", function () {
         let isTrueLabel = new Label();
         let isFalseLabel = new Label();
         let expected = [
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('b'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new EcmaStricteqdyn(new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Stricteq(new Imm(3), new VReg()),
             new Jeqz(isTrueLabel),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(isFalseLabel),
             isTrueLabel,
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             isFalseLabel,
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -201,23 +213,25 @@ describe("WatchExpressions", function () {
         let ifTrueLabel = new Label();  //label1
 
         let expected = [
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('b'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new EcmaStricteqdyn(new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Stricteq(new Imm(3), new VReg()),
             new Jeqz(ifFalseLabel),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(ifTrueLabel),
             ifFalseLabel,
-            new LdaDyn(new VReg()), //lda.dyn v10
+            new Lda(new VReg()), //lda. v10
             ifTrueLabel,
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -230,18 +244,21 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('BigInt'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new FldaiDyn(new Imm(10.2)),
-            new StaDyn(new VReg()),
-            new EcmaCallarg1dyn(new VReg(), new VReg()),
-
-            new ReturnDyn()
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Fldai(new Imm(10.2)),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Callarg1(new Imm(3), new VReg()),
+
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -256,23 +273,25 @@ describe("WatchExpressions", function () {
         let isTrueLabel = new Label();
         let isFalseLabel = new Label();
         let expected = [
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('b'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new EcmaStricteqdyn(new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Stricteq(new Imm(3), new VReg()),
             new Jeqz(isTrueLabel),
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             new Jmp(isFalseLabel),
             isTrueLabel,
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
             isFalseLabel,
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -284,14 +303,16 @@ describe("WatchExpressions", function () {
         this
         `);
         let expected = [
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('this'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -306,15 +327,17 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaLdobjbyname("debuggerSetValue", new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), "debuggerSetValue"),
+            new Sta(new VReg()),
             new LdaStr("b"),
-            new StaDyn(new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
 
-            new ReturnDyn()
+            new Return()
         ];
         pandaGens.forEach((pg) => {
             if (pg.internalName == "#1#") {
@@ -331,11 +354,11 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaCreatearraywithbuffer(new Imm(1)),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
+            new Createarraywithbuffer(new Imm(0), "1"),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -348,17 +371,19 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaCreateobjectwithbuffer(new Imm(1)),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaLdobjbyname('debuggerSetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Createobjectwithbuffer(new Imm(0), "1"),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(1), 'debuggerSetValue'),
+            new Sta(new VReg()),
             new LdaStr('a'),
-            new StaDyn(new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(3), new VReg(), new VReg()),
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -371,16 +396,19 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('a'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaLdobjbyname('b', new VReg()),
-
-            new ReturnDyn()
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(3), 'b'),
+
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -393,16 +421,19 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaLdobjbyname('debuggerGetValue',new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('a'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaLdobjbyindex(new VReg(), new Imm(0)),
-
-            new ReturnDyn()
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyindex(new Imm(3), new Imm(0)),
+
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -415,17 +446,19 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('Function'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaNewobjdynrange(new Imm(2), [new VReg(), new VReg()]),
-
-            new ReturnDyn()
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Newobjrange(new Imm(3), new Imm(1), [new VReg()]),
+
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -438,28 +471,34 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('a'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(3), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('b'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(5), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(6), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('c'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(8), new VReg(), new VReg()),
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -472,15 +511,17 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaDefinefuncdyn('a', new Imm(0), new VReg()),
-            new StaDyn(new VReg),
-            new EcmaLdobjbyname('debuggerSetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Definefunc(new Imm(0), 'a', new Imm(0)),
+            new Sta(new VReg),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(1), 'debuggerSetValue'),
+            new Sta(new VReg()),
             new LdaStr('a'),
-            new StaDyn(new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(3), new VReg(), new VReg()),
 
-            new ReturnDyn()
+            new Return()
         ];
         pandaGens.forEach((pg) => {
             if (pg.internalName == "func_main_0") {
@@ -497,19 +538,21 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaCreateemptyarray(),
-            new StaDyn(new VReg()),
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Createemptyarray(new Imm(0)),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(1), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('abc'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new EcmaStownbyindex(new VReg(), new Imm(0)),
-            new LdaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-
-            new ReturnDyn()
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(3), new VReg(), new VReg()),
+            new Stownbyindex(new Imm(4), new VReg(), new Imm(0)),
+            new Lda(new VReg()),
+            new Lda(new VReg()),
+
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -522,15 +565,17 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('a'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new EcmaTypeofdyn(),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Typeof(new Imm(3)),
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -543,17 +588,20 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('doSomething'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaCallarg0dyn(new VReg()),
-            new LdaDyn(new VReg()),
-
-            new ReturnDyn()
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Callarg0(new Imm(3)),
+            new Lda(new VReg()),
+
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -572,36 +620,44 @@ describe("WatchExpressions", function () {
         let nextLabel = new Label();
 
         let expected = [
-            new EcmaAsyncfunctionenter(),
-            new StaDyn(new VReg()),
+            new Asyncfunctionenter(),
+            new Sta(new VReg()),
             beginLabel,
-            new EcmaLdobjbyname("debuggerGetValue", new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), "debuggerGetValue"),
+            new Sta(new VReg()),
             new LdaStr('abc'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaAsyncfunctionawaituncaught(new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaSuspendgenerator(new VReg(), new VReg()),
-            new EcmaResumegenerator(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaGetresumemode(new VReg()),
-            new StaDyn(new VReg()),
-            new LdaiDyn(new Imm(1)),
-            new EcmaEqdyn(new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Asyncfunctionawaituncaught(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Suspendgenerator(new VReg()),
+            new Lda(new VReg()),
+            new Resumegenerator(),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Getresumemode(),
+            new Sta(new VReg()),
+            new Ldai(new Imm(1)),
+            new Eq(new Imm(3), new VReg()),
             new Jeqz(nextLabel),
-            new LdaDyn(new VReg()),
-            new EcmaThrowdyn(),
+            new Lda(new VReg()),
+            new Throw(),
             nextLabel,
-            new LdaDyn(new VReg()),
-            new EcmaAsyncfunctionresolve(new VReg(), new VReg(), new VReg()),
-            new ReturnDyn(),
+            new Lda(new VReg()),
+            new Lda(new VReg()),
+            new Asyncfunctionresolve(new VReg()),
+            new Return(),
             endLabel,
-            new StaDyn(new VReg()),
-            new EcmaAsyncfunctionreject(new VReg(), new VReg(), new VReg()),
-            new ReturnDyn(),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Asyncfunctionreject(new VReg()),
+            new Return(),
         ];
 
         pandaGens.forEach((pg) => {
@@ -619,22 +675,27 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaLdobjbyname("debuggerGetValue", new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), "debuggerGetValue"),
+            new Sta(new VReg()),
             new LdaStr('a'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaDecdyn(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaLdobjbyname("debuggerSetValue", new VReg()),
-            new StaDyn(new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Dec(new Imm(3)),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(4), "debuggerSetValue"),
+            new Sta(new VReg()),
             new LdaStr('a'),
-            new StaDyn(new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(6), new VReg(), new VReg()),
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -647,23 +708,29 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('a'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaDecdyn(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaLdobjbyname('debuggerSetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Dec(new Imm(3)),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(4), 'debuggerSetValue'),
+            new Sta(new VReg()),
             new LdaStr('a'),
-            new StaDyn(new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new EcmaTonumeric(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(6), new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Tonumeric(new Imm(7)),
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -676,22 +743,26 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaLdobjbyname("debuggerGetValue", new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), "debuggerGetValue"),
+            new Sta(new VReg()),
             new LdaStr("a"),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaLdobjbyname("debuggerGetValue", new VReg()),
-            new StaDyn(new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(3), "debuggerGetValue"),
+            new Sta(new VReg()),
             new LdaStr("b"),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new EcmaAdd2dyn(new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(5), new VReg(), new VReg()),
+            new Add2(new Imm(6), new VReg()),
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -707,21 +778,23 @@ describe("WatchExpressions", function () {
         let ifFalseLabel = new Label();
 
         let expected = [
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('a'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new EcmaIstrue(),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(), new VReg()),
+            new Istrue(),
             new Jeqz(ifTrueLabel),
-            new LdaiDyn(new Imm(4)),
+            new Ldai(new Imm(4)),
             new Jmp(ifFalseLabel),
             ifTrueLabel,
-            new LdaiDyn(new Imm(2)),
+            new Ldai(new Imm(2)),
             ifFalseLabel,
 
-            new ReturnDyn()
+            new Return()
         ];
         expect(checkInstructions(insns, expected)).to.be.true;
     });
@@ -740,55 +813,60 @@ describe("WatchExpressions", function () {
         let endLabel = new Label();
 
         let expected = [
-            new EcmaCreategeneratorobj(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaSuspendgenerator(new VReg(), new VReg()),
-            new EcmaResumegenerator(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaGetresumemode(new VReg()),
-            new StaDyn(new VReg()),
-            new LdaiDyn(new Imm(0)),
-            new EcmaEqdyn(new VReg()),
+            new Creategeneratorobj(new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Suspendgenerator(new VReg()),
+            new Lda(new VReg()),
+            new Resumegenerator(),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Getresumemode(),
+            new Sta(new VReg()),
+            new Ldai(new Imm(0)),
+            new Eq(new Imm(0), new VReg()),
             new Jeqz(startLabel),
-            new LdaDyn(new VReg()),
-            new ReturnDyn(),
+            new Lda(new VReg()),
+            new Return(),
             startLabel,
-            new LdaiDyn(new Imm(1)),
-            new EcmaEqdyn(new VReg()),
+            new Ldai(new Imm(1)),
+            new Eq(new Imm(1), new VReg()),
             new Jeqz(thenLabel),
-            new LdaDyn(new VReg()),
-            new EcmaThrowdyn(),
+            new Lda(new VReg()),
+            new Throw(),
             thenLabel,
-            new LdaDyn(new VReg()),
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(2), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('a'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaCreateiterresultobj(new VReg(),new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaSuspendgenerator(new VReg(), new VReg()),
-            new EcmaResumegenerator(new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaGetresumemode(new VReg()),
-            new StaDyn(new VReg()),
-            new LdaiDyn(new Imm(0)),
-            new EcmaEqdyn(new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Callargs2(new Imm(4), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Createiterresultobj(new VReg(),new VReg()),
+            new Suspendgenerator(new VReg()),
+            new Lda(new VReg()),
+            new Resumegenerator(),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Getresumemode(),
+            new Sta(new VReg()),
+            new Ldai(new Imm(0)),
+            new Eq(new Imm(5), new VReg()),
             new Jeqz(nextLabel),
-            new LdaDyn(new VReg()),
-            new ReturnDyn(),
+            new Lda(new VReg()),
+            new Return(),
             nextLabel,
-            new LdaiDyn(new Imm(1)),
-            new EcmaEqdyn(new VReg()),
+            new Ldai(new Imm(1)),
+            new Eq(new Imm(6), new VReg()),
             new Jeqz(endLabel),
-            new LdaDyn(new VReg()),
-            new EcmaThrowdyn(),
+            new Lda(new VReg()),
+            new Throw(),
             endLabel,
-            new LdaDyn(new VReg()),
+            new Lda(new VReg()),
 
-            new ReturnDyn()
+            new Return()
         ];
 
         pandaGens.forEach((pg) => {
@@ -806,18 +884,21 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new EcmaLdobjbyname('debuggerGetValue', new VReg()),
-            new StaDyn(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(0), 'debuggerGetValue'),
+            new Sta(new VReg()),
             new LdaStr('b'),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(),new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(),new VReg()),
-            new StaDyn(new VReg()),
-            new EcmaLdobjbyname('length', new VReg()),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-
-            new ReturnDyn()
+            new Sta(new VReg()),
+            new Mov(new VReg(),new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(2), new VReg(),new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(3), 'length'),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+
+            new Return()
         ];
 
         pandaGens.forEach((pg) => {
@@ -835,21 +916,23 @@ describe("WatchExpressions", function () {
         `);
 
         let expected = [
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaDefineclasswithbuffer("#1#", new Imm(1), new Imm(0), new VReg(), new VReg()),
-            new StaDyn(new VReg()),
-            new LdaDyn(new VReg()),
-            new StaDyn(new VReg()),
-            new MovDyn(new VReg(), new VReg()),
-            new EcmaNewobjdynrange(new Imm(2), [new VReg(), new VReg()]),
-            new StaDyn(new VReg()),
-            new EcmaLdobjbyname("debuggerSetValue", new VReg()),
-            new StaDyn(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Defineclasswithbuffer(new Imm(0), "#1#", "1", new Imm(0), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Sta(new VReg()),
+            new Mov(new VReg(), new VReg()),
+            new Newobjrange(new Imm(1), new Imm(1), [new VReg()]),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Ldobjbyname(new Imm(2), "debuggerSetValue"),
+            new Sta(new VReg()),
             new LdaStr("a"),
-            new StaDyn(new VReg()),
-            new EcmaCallargs2dyn(new VReg(), new VReg(), new VReg()),
+            new Sta(new VReg()),
+            new Lda(new VReg()),
+            new Callargs2(new Imm(4), new VReg(), new VReg()),
 
-            new ReturnDyn()
+            new Return()
         ];
         pandaGens.forEach((pg) => {
             if (pg.internalName == "func_main_0") {
diff --git a/ts2panda/ts2abc/ts2abc.cpp b/ts2panda/ts2abc/ts2abc.cpp
index ebd96d2f48ed0c7b34cb6b6d9a3aa652fe951d03..c366e097f0eeba847590571fb352db285ddffce6 100644
--- a/ts2panda/ts2abc/ts2abc.cpp
+++ b/ts2panda/ts2abc/ts2abc.cpp
@@ -781,6 +781,21 @@ static void ParseFunctionDeclaredType(const Json::Value &function, panda::pandas
     }
 }
 
+static void ParseFunctionKind(const Json::Value &function, panda::pandasm::Function &pandaFunc) {
+    panda::panda_file::FunctionKind funcKind {};
+    if (function.isMember("kind") && function["kind"].isInt()) {
+        funcKind = static_cast<panda::panda_file::FunctionKind>(function["kind"].asUInt());
+        pandaFunc.SetFunctionKind(funcKind);
+    }
+}
+
+static void ParseFunctionIcSize(const Json::Value &function, panda::pandasm::Function &pandaFunc) {
+    if (function.isMember("icSize") && function["icSize"].isInt()) {
+        size_t icSize = static_cast<size_t>(function["icSize"].asUInt());
+        pandaFunc.SetSlotsNum(icSize);
+    }
+}
+
 static panda::pandasm::Function ParseFunction(const Json::Value &function)
 {
     auto pandaFunc = GetFunctionDefintion(function);
@@ -794,6 +809,8 @@ static panda::pandasm::Function ParseFunction(const Json::Value &function)
     ParseFunctionTypeInfo(function, pandaFunc);
     ParseFunctionExportedType(function, pandaFunc);
     ParseFunctionDeclaredType(function, pandaFunc);
+    ParseFunctionKind(function, pandaFunc);
+    ParseFunctionIcSize(function, pandaFunc);
 
     if (g_isDtsFile && pandaFunc.name != "func_main_0") {
         pandaFunc.metadata->SetAttribute("external");
diff --git a/ts2panda/ts2abc/type_adapter.cpp b/ts2panda/ts2abc/type_adapter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3f95b4fe7b2cc0ca3109ec8d40470131bc528e45
--- /dev/null
+++ b/ts2panda/ts2abc/type_adapter.cpp
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "type_adapter.h"
+#include "assembler/meta.h"
+
+namespace ts2abc_type_adapter {
+void TypeAdapter::AdaptTypeForProgram(panda::pandasm::Program *prog) const
+{
+    for (auto &[name, func] : prog->function_table) {
+        if (ShouldDisplayTypeInfo()) {
+            std::cout << "Handle types for function: " << name << "\n";
+        }
+        AdaptTypeForFunction(&func);
+    }
+}
+
+void TypeAdapter::AdaptTypeForFunction(panda::pandasm::Function *func) const
+{
+    const auto &annos = func->metadata->GetAnnotations();
+    std::unordered_map<int32_t, int32_t> vreg_type_map;
+    size_t anno_idx = 0;
+    size_t ele_idx = 0;
+    for (; anno_idx < annos.size(); anno_idx++) {
+        const auto &anno_data = annos[anno_idx];
+        if (anno_data.GetName() != TSTYPE_ANNO_RECORD_NAME) {
+            continue;
+        }
+        const auto &elements = anno_data.GetElements();
+        for (; ele_idx < elements.size(); ele_idx++) {
+            const auto &element = elements[ele_idx];
+            if (element.GetName() != TSTYPE_ANNO_ELEMENT_NAME) {
+                continue;
+            }
+            const auto *array_value = element.GetValue();
+            ASSERT(array_value->IsArray());
+            const auto &values = array_value->GetAsArray()->GetValues();
+            size_t i = 0;
+            while (i < values.size()) {
+                auto vreg = static_cast<int32_t>(values[i++].GetValue<uint32_t>());
+                auto type = static_cast<int32_t>(values[i++].GetValue<uint32_t>());
+                vreg_type_map.emplace(vreg, type);
+            }
+            break;
+        }
+        break;
+    }
+    if (!vreg_type_map.empty()) {
+        HandleTypeForFunction(func, anno_idx, ele_idx, vreg_type_map);
+    }
+}
+
+static bool MaybeArg(const panda::pandasm::Function *func, size_t idx)
+{
+    return idx < func->params.size() && func->ins[idx].opcode == panda::pandasm::Opcode::MOV;
+}
+
+void TypeAdapter::HandleTypeForFunction(panda::pandasm::Function *func, size_t anno_idx, size_t ele_idx,
+                                        const std::unordered_map<int32_t, int32_t> &vreg_type_map) const
+{
+    std::unordered_map<int32_t, int32_t> order_type_map;
+    std::vector<int32_t> finished_vregs;
+    int32_t order = 0;
+    for (size_t i = 0; i < func->ins.size(); i++) {
+        const auto &insn = func->ins[i];
+        if (insn.opcode == panda::pandasm::Opcode::INVALID) {
+            continue;
+        }
+        order++;
+
+        FillInBuiltinType(insn, order_type_map, order);
+
+        bool maybe_arg = MaybeArg(func, i);
+        if (!maybe_arg && insn.opcode != panda::pandasm::Opcode::STA) {
+            continue;
+        }
+        if (maybe_arg) {
+            auto vreg = insn.regs[0];
+            auto arg = insn.regs[1];
+            if (vreg >= func->params.size() || arg < func->regs_num) {
+                continue;  // not arg
+            }
+            auto it = vreg_type_map.find(vreg);
+            if (it != vreg_type_map.end()) {
+                ASSERT(std::find(finished_vregs.begin(), finished_vregs.end(), vreg) == finished_vregs.end());
+                int32_t arg_order = static_cast<int32_t>(func->regs_num) - static_cast<int32_t>(arg) - 1;
+                order_type_map.emplace(arg_order, it->second);
+                finished_vregs.emplace_back(vreg);
+            }
+            continue;
+        }
+
+        // vregs binded with variables must be filled through sta_dyn
+        ASSERT(insn.opcode == panda::pandasm::Opcode::STA);
+        ASSERT(!insn.regs.empty());
+        auto vreg = insn.regs[0];
+        auto it = vreg_type_map.find(vreg);
+        if (it != vreg_type_map.end() &&
+                  std::find(finished_vregs.begin(), finished_vregs.end(), vreg) == finished_vregs.end()) {
+            order_type_map.emplace(order - 1, it->second);
+            finished_vregs.emplace_back(vreg);
+        }
+    }
+
+    UpdateTypeAnnotation(func, anno_idx, ele_idx, order_type_map);
+}
+
+void TypeAdapter::FillInBuiltinType(const panda::pandasm::Ins &insn,
+                                    std::unordered_map<int32_t, int32_t> &order_type_map,
+                                    const int32_t order) const
+{
+    if (insn.opcode != panda::pandasm::Opcode::TRYLDGLOBALBYNAME) {
+        return;
+    }
+
+    auto objName = insn.ids[0];
+    auto typeIter = std::find(builtinTypes.begin(), builtinTypes.end(), objName);
+    if (typeIter != builtinTypes.end()) {
+        int builtinTypeIdx = typeIter - builtinTypes.begin() + builtinTypeOffset;
+        order_type_map.emplace(order - 1, builtinTypeIdx);
+    }
+}
+
+void TypeAdapter::UpdateTypeAnnotation(panda::pandasm::Function *func, size_t anno_idx, size_t ele_idx,
+                                       const std::unordered_map<int32_t, int32_t> &order_type_map) const
+{
+    ASSERT(anno_idx <= func->metadata->GetAnnotations().size());
+    if (anno_idx == func->metadata->GetAnnotations().size()) {
+        std::vector<panda::pandasm::AnnotationData> added_datas;
+        panda::pandasm::AnnotationData data(TSTYPE_ANNO_RECORD_NAME);
+        added_datas.push_back(std::forward<panda::pandasm::AnnotationData>(data));
+        func->metadata->AddAnnotations(std::forward<std::vector<panda::pandasm::AnnotationData>>(added_datas));
+        ele_idx = 0;
+    }
+
+    using ArrayValue = panda::pandasm::ArrayValue;
+    using ScalarValue = panda::pandasm::ScalarValue;
+    std::vector<ScalarValue> elements;
+    for (const auto &[order, type] : order_type_map) {
+        ScalarValue insn_order(ScalarValue::Create<panda::pandasm::Value::Type::I32>(order));
+        elements.emplace_back(std::move(insn_order));
+        ScalarValue insn_type(ScalarValue::Create<panda::pandasm::Value::Type::I32>(type));
+        elements.emplace_back(std::move(insn_type));
+    }
+
+    ArrayValue arr(panda::pandasm::Value::Type::I32, elements);
+    panda::pandasm::AnnotationElement anno_ele(TSTYPE_ANNO_ELEMENT_NAME, std::make_unique<ArrayValue>(arr));
+    func->metadata->SetOrAddAnnotationElementByIndex(anno_idx, ele_idx, std::move(anno_ele));
+
+    if (ShouldDisplayTypeInfo()) {
+        std::cout << "(instruction order, type): ";
+        const auto data = func->metadata->GetAnnotations()[anno_idx];
+        const auto vars = data.GetElements()[ele_idx].GetValue()->GetAsArray()->GetValues();
+        size_t pair_gap = 2;
+        for (size_t i = 0; i < vars.size(); i += pair_gap) {
+            std::cout << "(" << static_cast<int32_t>(vars[i].GetValue<int32_t>()) << ", "
+                      << static_cast<int32_t>(vars[i + 1].GetValue<uint32_t>()) << "), ";
+        }
+        std::cout << "\n";
+    }
+}
+}  // namespace ts2abc_type_adapter