diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/Compiler.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/Compiler.java
index 2af000e..ce7aa93 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/Compiler.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/Compiler.java
@@ -4,23 +4,43 @@
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonTokenStream;
 import org.antlr.v4.runtime.tree.ParseTree;
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.teachfx.antlr4.ep21.ast.ASTNode;
+import org.teachfx.antlr4.ep21.ir.IRNode;
+import org.teachfx.antlr4.ep21.ir.stmt.Label;
 import org.teachfx.antlr4.ep21.parser.CymbolLexer;
 import org.teachfx.antlr4.ep21.parser.CymbolParser;
 import org.teachfx.antlr4.ep21.pass.ast.CymbolASTBuilder;
+import org.teachfx.antlr4.ep21.pass.cfg.CFG;
 import org.teachfx.antlr4.ep21.pass.cfg.ControlFlowAnalysis;
 import org.teachfx.antlr4.ep21.pass.codegen.CymbolAssembler;
 import org.teachfx.antlr4.ep21.pass.ir.CymbolIRBuilder;
 import org.teachfx.antlr4.ep21.pass.symtab.LocalDefine;
+import org.teachfx.antlr4.ep21.utils.StreamUtils;
 
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
+import java.io.*;
+import java.util.ArrayList;
+import java.util.LinkedList;
 import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
 
 public class Compiler {
 
+    private final  static Logger logger = LogManager.getLogger(Compiler.class);
+    protected static void printIRTree(List<IRNode> irNodeList) {
+        var prettyFormatText = irNodeList.stream().map(irNode -> {
+            if (irNode instanceof Label) {
+                return irNode.toString();
+            }
+            return "    "+irNode.toString();
+        }).reduce((a, b) -> a + "\n" + b);
+        prettyFormatText.ifPresent(logger::debug);
+    }
+
     public static void main(String[] args) throws IOException {
         String fileName = args.length > 0 ? args[0] : (new File("src/main/resources/t.cymbol")).getAbsolutePath();
 
@@ -31,23 +51,98 @@ public static void main(String[] args) throws IOException {
         CommonTokenStream tokenStream = new CommonTokenStream(lexer);
         CymbolParser parser = new CymbolParser(tokenStream);
         ParseTree parseTree = parser.file();
-        CymbolASTBuilder astBuilder = new CymbolASTBuilder("t.cymbol");
+
+        CymbolASTBuilder astBuilder = new CymbolASTBuilder();
+
         ASTNode astRoot = parseTree.accept(astBuilder);
+
         astRoot.accept(new LocalDefine());
+
         var irBuilder = new CymbolIRBuilder();
 
         astRoot.accept(irBuilder);
 
-        var dataFlowAnalysis = new ControlFlowAnalysis();
+        irBuilder.prog.optimizeBasicBlock();
+
+        Stream.of(
+                        StreamUtils.indexStream(irBuilder.prog.blockList.stream()
+                                        .map(irBuilder::getCFG))
+                                .peek(cfgPair -> {
+                                    var cfg = cfgPair.getRight();
+                                    var idx = cfgPair.getLeft();
+                                    saveToEp20Res(cfg.toString(), "%d_origin".formatted(idx));
+                                    cfg.addOptimizer(new ControlFlowAnalysis<>());
+                                    cfg.applyOptimizers();
+                                    saveToEp20Res(cfg.toString(), "%d_optimized".formatted(idx));
+                                })
+                                .map(Pair::getRight)
+                                .map(CFG::getIRNodes)
+                                .reduce(new ArrayList<IRNode>(), (a, b) -> {
+                                    a.addAll(b);
+                                    return a;
+                                })
+                )
+                .map(irNodeList -> {
+                    var assembler = new CymbolAssembler();
+                    assembler.visit(irNodeList);
+                    return assembler;
+                })
+                .forEach(assembler -> {
+                    saveToEp18Res(assembler.getAsmInfo());
+                    logger.debug("\n%s".formatted(assembler.getAsmInfo()));
+                });
+    }
+
+    protected static void saveToEp18Res(String buffer) {
+        String modulePath = "../ep18/src/main/resources"; // 替换 "my-module" 为你的模块名称
+        File moduleDirectory = new File(modulePath);
+        logger.debug("file path %s".formatted(moduleDirectory.getAbsolutePath()));
+        if (moduleDirectory.exists()) {
+            logger.debug("模块路径：" + moduleDirectory.getAbsolutePath());
+            var filePath = modulePath+"/t.vm";
+            File file = new File(filePath);
+            try (var outputStream = new FileOutputStream(file)) {
+                if (!file.exists()) {
+                    var res = file.createNewFile();
+                    logger.debug("create file %s is %b".formatted(filePath,res));
+                }
+                outputStream.write(buffer.getBytes());
+
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+
+        } else {
+            logger.error("模块路径不存在！");
+        }
+    }
 
-        var assembler = new CymbolAssembler();
+    protected static void saveToEp20Res(String buffer,String suffix) {
+        String modulePath = "./src/main/resources"; // 替换 "my-module" 为你的模块名称
+        File moduleDirectory = new File(modulePath);
+        logger.debug("file path %s".formatted(moduleDirectory.getAbsolutePath()));
+        if (moduleDirectory.exists()) {
+            logger.debug("模块路径：" + moduleDirectory.getAbsolutePath());
+            var filePath = modulePath+"/graph_%s.md".formatted(suffix);
+            File file = new File(filePath);
+            try (var outputStream = new FileOutputStream(file)) {
+                if (!file.exists()) {
+                   var res = file.createNewFile();
+                   logger.debug("create file %s is %b".formatted(filePath,res));
+                }
+                String template = """
+                        ```mermaid
+                        %s
+                        ```
+                        """.formatted(buffer);
+                outputStream.write(template.getBytes());
 
-        List.of(dataFlowAnalysis,assembler).forEach(irBuilder.root::accept);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
 
-        System.out.println(assembler.flushCode());
-        var url = Compiler.class.getClassLoader().getResource("t.vm");
-        System.out.println(">>>=" + new File(".").getAbsolutePath());
-        assembler.saveToFile("src/main/resources/t.vm");
-        assembler.saveToFile("../ep18/src/main/resources/t.vm");
+        } else {
+            logger.error("模块路径不存在！");
+        }
     }
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/ASTNode.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/ASTNode.java
index efde85c..dcf2b96 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/ASTNode.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/ASTNode.java
@@ -39,5 +39,10 @@ public void dump(Dumper d) {
     }
 
     abstract protected void _dump(Dumper d);
+
+    @Override
+    public String toString() {
+        return ctx.getText();
+    }
 }
 
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/CompileUnit.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/CompileUnit.java
index a8fbb2c..43760ec 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/CompileUnit.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/CompileUnit.java
@@ -9,7 +9,6 @@
 import java.util.List;
 
 public class CompileUnit extends ASTNode {
-    private String srcName;
 
     public void addFuncDecl(FuncDeclNode funcDecl) {
         this.funcDeclarations.add(funcDecl);
@@ -29,9 +28,7 @@ public CompileUnit(List<VarDeclNode> varDeclarations, List<FuncDeclNode> funcDec
         this.ctx = ctx;
     }
 
-    public CompileUnit(String srcName) {
-        this.srcName = srcName;
-    }
+    public CompileUnit() {}
 
     public List<VarDeclNode> getVarDeclarations() {
         return varDeclarations;
@@ -56,14 +53,6 @@ protected void _dump(Dumper d) {
         d.printNodeList("funcDecl",funcDeclarations);
     }
 
-    public String getSrcName() {
-        return srcName;
-    }
-
-    public void setSrcName(String srcName) {
-        this.srcName = srcName;
-    }
-
     @Override
     public void accept(ASTVisitor visitor) {
         visitor.visit(this);
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/decl/VarDeclNode.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/decl/VarDeclNode.java
index ae7b6e5..5ec9380 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/decl/VarDeclNode.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/decl/VarDeclNode.java
@@ -3,12 +3,15 @@
 import org.antlr.v4.runtime.ParserRuleContext;
 import org.teachfx.antlr4.ep21.ast.ASTVisitor;
 import org.teachfx.antlr4.ep21.ast.expr.ExprNode;
+import org.teachfx.antlr4.ep21.ast.expr.IDExprNode;
 import org.teachfx.antlr4.ep21.debugger.ast.Dumper;
 import org.teachfx.antlr4.ep21.symtab.symbol.VariableSymbol;
 
 import java.util.Objects;
 
 public class VarDeclNode extends DeclNode {
+    private IDExprNode idExprNode;
+
     private ExprNode assignExprNode;
 
     public ExprNode initializerExpr() {
@@ -20,10 +23,11 @@ public boolean hasInitializer() {
     }
 
 
-    public VarDeclNode(VariableSymbol variableSymbol,ExprNode assignExprNode, ParserRuleContext ctx) {
+    public VarDeclNode(VariableSymbol variableSymbol,ExprNode assignExprNode,IDExprNode idExprNode, ParserRuleContext ctx) {
         this.refSymbol = variableSymbol;
         this.assignExprNode = assignExprNode;
         this.ctx = ctx;
+        this.idExprNode = idExprNode;
         this.declName = variableSymbol.getName();
     }
 
@@ -52,4 +56,12 @@ protected void _dump(Dumper d) {
         d.printMember("type",getRefSymbol().getType());
         if (Objects.nonNull(assignExprNode)) d.printMember("assignee",assignExprNode);
     }
+
+    public IDExprNode getIdExprNode() {
+        return idExprNode;
+    }
+
+    public void setIdExprNode(IDExprNode idExprNode) {
+        this.idExprNode = idExprNode;
+    }
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/expr/IDExprNode.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/expr/IDExprNode.java
index f2924b2..9592412 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/expr/IDExprNode.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/expr/IDExprNode.java
@@ -13,12 +13,21 @@ public class IDExprNode extends ExprNode {
 
     protected Symbol refSymbol;
 
+    protected boolean isVal = false;
+
     public IDExprNode(String image,ParserRuleContext ctx) {
         this.image = image;
         this.ctx = ctx;
 
     }
 
+    public boolean isLValue() {
+        return isVal;
+    }
+
+    public void setLValue(boolean isVal) {
+        this.isVal = isVal;
+    }
 
     public Symbol getRefSymbol() {
         return refSymbol;
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/stmt/IfStmtNode.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/stmt/IfStmtNode.java
index 6fd213d..156c252 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/stmt/IfStmtNode.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ast/stmt/IfStmtNode.java
@@ -21,7 +21,7 @@ public IfStmtNode(ExprNode exprNode, StmtNode then, StmtNode elseBlock, ParserRu
         this.ctx = ctx;
     }
 
-    public ExprNode getConditionalNode() {
+    public ExprNode getCondExpr() {
         return conditionalNode;
     }
 
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/driver/Phase.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/driver/Phase.java
index 4bad0f5..f7feb51 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/driver/Phase.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/driver/Phase.java
@@ -3,7 +3,6 @@
 import java.util.Optional;
 
 public abstract class Phase<Input,Output> implements Task<Input,Output>,ErrorIssuer {
-
     public final String name;
 
     public Phase(String name) {
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/IRVisitor.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/IRVisitor.java
index 1a76244..5ad2164 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/IRVisitor.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/IRVisitor.java
@@ -1,23 +1,14 @@
 package org.teachfx.antlr4.ep21.ir;
 
-import org.teachfx.antlr4.ep21.ir.def.Func;
-import org.teachfx.antlr4.ep21.ir.expr.ArrayAccessExpr;
 import org.teachfx.antlr4.ep21.ir.expr.CallFunc;
-import org.teachfx.antlr4.ep21.ir.expr.ClassAccessExpr;
-import org.teachfx.antlr4.ep21.ir.expr.Temp;
+import org.teachfx.antlr4.ep21.ir.expr.addr.FrameSlot;
+import org.teachfx.antlr4.ep21.ir.expr.addr.OperandSlot;
 import org.teachfx.antlr4.ep21.ir.expr.arith.BinExpr;
 import org.teachfx.antlr4.ep21.ir.expr.arith.UnaryExpr;
-import org.teachfx.antlr4.ep21.ir.expr.values.BoolVal;
-import org.teachfx.antlr4.ep21.ir.expr.values.IntVal;
-import org.teachfx.antlr4.ep21.ir.expr.values.StringVal;
-import org.teachfx.antlr4.ep21.ir.expr.values.Var;
+import org.teachfx.antlr4.ep21.ir.expr.val.ConstVal;
 import org.teachfx.antlr4.ep21.ir.stmt.*;
 
 public interface IRVisitor<S,E> {
-    /// Expr
-    E visit(IntVal node);
-    E visit(BoolVal node);
-    E visit(StringVal node);
 
     E visit(BinExpr node);
 
@@ -30,22 +21,18 @@ public interface IRVisitor<S,E> {
     S visit(CJMP cjmp);
     S visit(Assign assign);
 
-    S visit(Func func);
-
-    E visit(Var var);
-
-    E visit(ClassAccessExpr classAccessExpr);
-
-    E visit(ArrayAccessExpr arrayAccessExpr);
-
     default S visit(Stmt stmt) { return stmt.accept(this);}
 
     S visit(ReturnVal returnVal);
-    S visit(ExprStmt exprStmt);
+    default S visit(ExprStmt exprStmt) { return exprStmt.accept(this); }
+
+    default S visit(Prog prog) { return null; }
+
+    E visit(OperandSlot operandSlot);
 
-    S visit(Prog prog);
+    E visit(FrameSlot frameSlot);
 
-    E visit(Temp temp);
+    <T> E visit(ConstVal<T> tConstVal);
 
     /// Stmt
 
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/JMPInstr.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/JMPInstr.java
new file mode 100644
index 0000000..7fcc6eb
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/JMPInstr.java
@@ -0,0 +1,7 @@
+package org.teachfx.antlr4.ep21.ir;
+
+import org.teachfx.antlr4.ep21.ir.stmt.Label;
+
+public interface JMPInstr {
+    public Label getTarget();
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/Prog.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/Prog.java
index f8d0e1d..3e28037 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/Prog.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/Prog.java
@@ -1,16 +1,25 @@
 package org.teachfx.antlr4.ep21.ir;
 
-import org.teachfx.antlr4.ep21.ir.def.Func;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.NotNull;
+import org.teachfx.antlr4.ep21.ir.stmt.CJMP;
+import org.teachfx.antlr4.ep21.ir.stmt.FuncEntryLabel;
+import org.teachfx.antlr4.ep21.ir.stmt.JMP;
+import org.teachfx.antlr4.ep21.ir.stmt.Label;
+import org.teachfx.antlr4.ep21.pass.cfg.LinearIRBlock;
+
+import java.util.*;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
 
 public class Prog extends IRNode {
-    public List<Func> defuncList;
+    public List<LinearIRBlock> blockList;
+    protected static Logger logger = LogManager.getLogger(Prog.class);
+    public List<IRNode> instrs = new ArrayList<>();
 
-    public Prog(List<Func> stmts) {
-        this.defuncList = Objects.isNull(stmts) ? new ArrayList<>() : stmts;
+    private final List<IRNode> truncateInstrList = new LinkedList<>();
+    public Prog() {
+        this.blockList = new ArrayList<>() ;
     }
 
     public <S,E> S accept(IRVisitor<S,E> visitor){
@@ -18,10 +27,111 @@ public <S,E> S accept(IRVisitor<S,E> visitor){
         return visitor.visit(this);
     }
 
-    public void addFunc(Func func) {
-        if (Objects.isNull(defuncList))
-            defuncList = List.of(func);
-        else if (!defuncList.contains(func) && func != null)
-            defuncList.add(func);
+    public void addBlock(LinearIRBlock linearIRBlock) {
+        blockList.add(linearIRBlock);
+    }
+    protected TreeSet<LinearIRBlock> needRemovedBlocks = new TreeSet<>();
+
+    private void optimizeEmptyBlock(@NotNull LinearIRBlock linearIRBlock) {
+        // replace empty block within non-empty first successor
+        if (linearIRBlock.getStmts().isEmpty()){
+            // Drop empty block
+            if (linearIRBlock.getSuccessors().isEmpty()) {
+                logger.debug("Block %s will be removed".formatted(linearIRBlock));
+                needRemovedBlocks.add(linearIRBlock);
+                return;
+            }
+            // Auto-fill next block for jmp/cjmp
+            var nextBlock = linearIRBlock.getSuccessors().get(0);
+            for (var ref : linearIRBlock.getJmpRefMap()){
+                if (ref instanceof JMP jmp) {
+                    logger.debug(" %s is next for %s".formatted(nextBlock,linearIRBlock));
+                    jmp.setNext(nextBlock);
+
+                } else if (ref instanceof CJMP cjmp) {
+                    logger.debug(" %s is else-case for %s".formatted(nextBlock,linearIRBlock));
+                    cjmp.setElseBlock(nextBlock);
+                }
+            }
+
+            linearIRBlock.getPredecessors().forEach(prev -> {
+                prev.removeSuccessor(linearIRBlock);
+                prev.getSuccessors().add(nextBlock);
+            });
+
+            needRemovedBlocks.add(linearIRBlock);
+        }
+
+        // recursive call
+        for(var successor : linearIRBlock.getSuccessors()){
+            optimizeEmptyBlock(successor);
+        }
+    }
+
+    private void insertLabelForBlock(LinearIRBlock startBlock) {
+        for (var stmt : startBlock.getStmts()) {
+            if (stmt instanceof Label) {
+                break;
+            }
+
+            startBlock.insertStmt(new Label(startBlock.getScope(), startBlock.getOrd()),0);
+            break; // only insert one label for each block which is not func-entry block.
+        }
+
+        for (var successor : startBlock.getSuccessors()) {
+            insertLabelForBlock(successor);
+        }
+    }
+    protected void buildInstrs(LinearIRBlock block) {
+        instrs.addAll(block.getStmts());
+
+        for (var successor : block.getSuccessors()) {
+            buildInstrs(successor);
+        }
+
+    }
+
+    public void optimizeBasicBlock() {
+        for(var func : blockList) {
+            optimizeEmptyBlock(func);
+        }
+
+        for( var emptyBlock : needRemovedBlocks) {
+            emptyBlock.getPredecessors().forEach(p -> p.removeSuccessor(emptyBlock));
+        }
+
+        for(var func : blockList) {
+            insertLabelForBlock(func);
+        }
+    }
+
+    public List<IRNode> linearInstrs() {
+
+        if (!truncateInstrList.isEmpty()){
+            return truncateInstrList;
+        }
+
+        for(var func : blockList) {
+            buildInstrs(func);
+        }
+
+        IRNode prev;
+        IRNode cur = null;
+
+        for (IRNode instr : instrs) {
+            prev = cur;
+            cur = instr;
+            if (Objects.nonNull(prev) && prev instanceof Label) {
+                if (cur instanceof FuncEntryLabel) {
+                    truncateInstrList.remove(prev);
+                }
+            }
+
+            truncateInstrList.add(cur);
+        }
+
+        return truncateInstrList;
     }
+
+
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/def/Define.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/def/Define.java
deleted file mode 100644
index bd9cfad..0000000
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/def/Define.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package org.teachfx.antlr4.ep21.ir.def;
-
-import org.teachfx.antlr4.ep21.ir.IRNode;
-import org.teachfx.antlr4.ep21.ir.IRVisitor;
-import org.teachfx.antlr4.ep21.symtab.symbol.Symbol;
-
-public abstract class Define extends IRNode {
-    public Symbol symbol;
-
-    public abstract String getDeclName();
-
-    //IR Visitor
-    public abstract <S,E> S accept(IRVisitor<S,E> visitor);
-
-
-
-}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/def/Func.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/def/Func.java
deleted file mode 100644
index 927c1c2..0000000
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/def/Func.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package org.teachfx.antlr4.ep21.ir.def;
-
-import org.teachfx.antlr4.ep21.ir.IRVisitor;
-import org.teachfx.antlr4.ep21.ir.stmt.ReturnVal;
-import org.teachfx.antlr4.ep21.ir.stmt.Stmt;
-import org.teachfx.antlr4.ep21.symtab.symbol.MethodSymbol;
-
-import java.util.List;
-
-public class Func extends Define {
-    /// filed
-    public String funcName;
-    private int locals;
-    public List<Stmt> body;
-    public ReturnVal retHook;
-
-    public Func(String funcName, MethodSymbol symbol , List<Stmt> body) {
-        // init
-        this.funcName = funcName;
-        this.symbol = symbol;
-        this.body = body;
-    }
-
-    public String getFuncName() {
-        return funcName;
-    }
-
-    public void setFuncName(String funcName) {
-        this.funcName = funcName;
-    }
-
-    public int getArgs() {
-        return getFuncSymbol().getMembers().size();
-    }
-    protected MethodSymbol getFuncSymbol() {
-        return (MethodSymbol)symbol;
-    }
-    public int getLocals() {
-        return locals;
-    }
-
-    public void setLocals(int locals) {
-        this.locals = locals;
-    }
-
-    public List<Stmt> getBody() {
-        return body;
-    }
-
-    public void setBody(List<Stmt> body) {
-        this.body = body;
-    }
-
-    @Override
-    public String getDeclName() {
-        return getFuncName();
-    }
-
-    @Override
-    public <S, E> S accept(IRVisitor<S, E> visitor) {
-        return visitor.visit(this);
-    }
-
-    public String toSource() {
-        return ".def %s: args=%d ,locals=%d".formatted(getFuncName(), getFuncSymbol().getArgs(),getFuncSymbol().getMembers().size() -  getFuncSymbol().getArgs());
-    }
-}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/ArrayAccessExpr.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/ArrayAccessExpr.java
deleted file mode 100644
index 6d4d312..0000000
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/ArrayAccessExpr.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package org.teachfx.antlr4.ep21.ir.expr;
-
-
-import org.teachfx.antlr4.ep21.ir.IRVisitor;
-
-public class ArrayAccessExpr extends Expr {
-
-    private Expr arrayExpr;
-    private Expr indexExpr;
-
-    public Expr getArrayExpr() {
-        return arrayExpr;
-
-    }
-
-    public Expr getIndexExpr() {
-        return indexExpr;
-    }
-
-    @Override
-    public <S, E> E accept(IRVisitor<S, E> visitor) {
-        return visitor.visit(this);
-    }
-}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/CallFunc.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/CallFunc.java
index 7e71a8f..b81b01e 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/CallFunc.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/CallFunc.java
@@ -2,37 +2,41 @@
 
 
 import org.teachfx.antlr4.ep21.ir.IRVisitor;
-import org.teachfx.antlr4.ep21.ir.expr.values.Var;
-
-import java.util.List;
-
-public class CallFunc extends Expr{
-    protected List<Expr> args;
-    protected Var funcExpr;
-
-    public CallFunc(Var funcExpr,List<Expr> args) {
-        this.funcExpr = funcExpr;
+import org.teachfx.antlr4.ep21.symtab.symbol.MethodSymbol;
+
+public class CallFunc extends Expr {
+    protected MethodSymbol funcType;
+    protected String funcName;
+    protected int args;
+    public CallFunc(String funcName,int args,MethodSymbol funcType) {
+        this.funcName = funcName;
         this.args = args;
+        this.funcType = funcType;
     }
 
-    public Var getFuncExpr() {
-        return funcExpr;
+    public String getFuncName() {
+        return funcName;
     }
 
-    public void setFuncExpr(Var funcExpr) {
-        this.funcExpr = funcExpr;
+    public void setFuncName(String funcName) {
+        this.funcName = funcName;
     }
 
-    public List<Expr> getArgs() {
+    public int getArgs() {
         return args;
     }
 
-    public void setArgs(List<Expr> args) {
-        this.args = args;
+    public MethodSymbol getFuncType() {
+        return funcType;
     }
 
     @Override
     public <S, E> E accept(IRVisitor<S, E> visitor) {
         return visitor.visit(this);
     }
+
+    @Override
+    public String toString() {
+        return "call " + funcName + "(args:" + args + ")";
+    }
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/ClassAccessExpr.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/ClassAccessExpr.java
deleted file mode 100644
index d4b8e37..0000000
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/ClassAccessExpr.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package org.teachfx.antlr4.ep21.ir.expr;
-
-import org.teachfx.antlr4.ep21.ir.IRVisitor;
-
-public class ClassAccessExpr extends Expr
-{
-    private Expr expr;
-    private String name;
-
-    public ClassAccessExpr(Expr expr, String name) {
-        this.expr = expr;
-        this.name = name;
-    }
-
-    @Override
-    public <S, E> E accept(IRVisitor<S, E> visitor) {
-        return visitor.visit(this);
-    }
-
-    @Override
-    public String toString()
-    {
-        return "ClassAccessExpr [expr=" + expr + ", name=" + name + "]";
-    }
-}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/Expr.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/Expr.java
index e6dae6b..50c0ae9 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/Expr.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/Expr.java
@@ -4,6 +4,5 @@
 import org.teachfx.antlr4.ep21.ir.IRVisitor;
 
 public abstract class Expr extends IRNode {
-
-    abstract public <S,E> E accept(IRVisitor<S,E> visitor);
+    public abstract <S,E> E accept(IRVisitor<S,E> visitor);
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/ImmValue.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/ImmValue.java
new file mode 100644
index 0000000..21724a7
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/ImmValue.java
@@ -0,0 +1,5 @@
+package org.teachfx.antlr4.ep21.ir.expr;
+
+public abstract class ImmValue extends Operand {
+
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/Operand.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/Operand.java
new file mode 100644
index 0000000..aadc5e8
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/Operand.java
@@ -0,0 +1,7 @@
+package org.teachfx.antlr4.ep21.ir.expr;
+
+import org.teachfx.antlr4.ep21.ir.IRVisitor;
+
+public abstract class Operand extends Expr {
+    abstract public <S,E> E accept(IRVisitor<S,E> visitor);
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/Temp.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/Temp.java
deleted file mode 100644
index 73e5fc5..0000000
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/Temp.java
+++ /dev/null
@@ -1,15 +0,0 @@
-package org.teachfx.antlr4.ep21.ir.expr;
-
-import org.teachfx.antlr4.ep21.ir.IRVisitor;
-
-public class Temp extends Expr{
-
-    public Temp() {
-        super();
-    }
-
-    @Override
-    public <S, E> E accept(IRVisitor<S, E> visitor) {
-        return visitor.visit(this);
-    }
-}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/VarSlot.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/VarSlot.java
new file mode 100644
index 0000000..7a4104e
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/VarSlot.java
@@ -0,0 +1,5 @@
+package org.teachfx.antlr4.ep21.ir.expr;
+
+public abstract class VarSlot extends Operand {
+
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/addr/FrameSlot.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/addr/FrameSlot.java
new file mode 100644
index 0000000..df52619
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/addr/FrameSlot.java
@@ -0,0 +1,31 @@
+package org.teachfx.antlr4.ep21.ir.expr.addr;
+
+import org.teachfx.antlr4.ep21.ir.IRVisitor;
+import org.teachfx.antlr4.ep21.ir.expr.VarSlot;
+import org.teachfx.antlr4.ep21.symtab.symbol.VariableSymbol;
+
+public class FrameSlot extends VarSlot {
+
+    protected int slotIdx = 0;
+
+    public static FrameSlot get(VariableSymbol variableSymbol) {
+        return new FrameSlot(variableSymbol.getSlotIdx());
+    }
+
+    public FrameSlot(int idx) {
+        this.slotIdx = idx;
+    }
+    public int getSlotIdx() {
+        return slotIdx;
+    }
+
+    @Override
+    public <S, E> E accept(IRVisitor<S, E> visitor) {
+        return visitor.visit(this);
+    }
+
+    @Override
+    public String toString() {
+        return "@%d".formatted(slotIdx);
+    }
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/addr/OperandSlot.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/addr/OperandSlot.java
new file mode 100644
index 0000000..7f02e80
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/addr/OperandSlot.java
@@ -0,0 +1,38 @@
+package org.teachfx.antlr4.ep21.ir.expr.addr;
+
+import org.teachfx.antlr4.ep21.ir.IRVisitor;
+import org.teachfx.antlr4.ep21.ir.expr.VarSlot;
+
+public class OperandSlot extends VarSlot {
+    private static int ordSeq = 0;
+
+    public static OperandSlot genTemp() {
+        return new OperandSlot();
+    }
+
+    private int ord = 0;
+    private OperandSlot() {
+        this.ord = OperandSlot.ordSeq++;
+    }
+    public int getOrd() {
+        return ord;
+    }
+
+    @Override
+    public String toString() {
+        return "t"+ ord ;
+    }
+
+    @Override
+    public <S, E> E accept(IRVisitor<S, E> visitor) {
+        return visitor.visit(this);
+    }
+
+
+    public static OperandSlot pushStack() { return OperandSlot.genTemp(); }
+    public static void popStack() { ordSeq--;}
+
+    public static int getOrdSeq() {
+        return ordSeq;
+    }
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/arith/BinExpr.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/arith/BinExpr.java
index b1cb851..0d57743 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/arith/BinExpr.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/arith/BinExpr.java
@@ -2,33 +2,35 @@
 
 import org.teachfx.antlr4.ep21.ir.IRVisitor;
 import org.teachfx.antlr4.ep21.ir.expr.Expr;
+import org.teachfx.antlr4.ep21.ir.expr.Operand;
+import org.teachfx.antlr4.ep21.ir.expr.VarSlot;
 import org.teachfx.antlr4.ep21.symtab.type.OperatorType;
 
 public class BinExpr extends Expr {
 
-    protected Expr lhs;
-    protected Expr rhs;
+    protected VarSlot lhs;
+    protected VarSlot rhs;
     protected OperatorType.BinaryOpType opType;
 
-    public BinExpr(OperatorType.BinaryOpType op, Expr left, Expr right) {
+    public BinExpr(OperatorType.BinaryOpType op, VarSlot left, VarSlot right) {
         this.opType = op;
         this.lhs = left;
         this.rhs = right;
     }
 
-    public Expr getLhs() {
+    public VarSlot getLhs() {
         return lhs;
     }
 
-    public void setLhs(Expr lhs) {
+    public void setLhs(VarSlot lhs) {
         this.lhs = lhs;
     }
 
-    public Expr getRhs() {
+    public VarSlot getRhs() {
         return rhs;
     }
 
-    public void setRhs(Expr rhs) {
+    public void setRhs(VarSlot rhs) {
         this.rhs = rhs;
     }
 
@@ -42,11 +44,17 @@ public void setOpType(OperatorType.BinaryOpType opType) {
 
     @Override
     public String toString() {
-        return "BinaryExpr";
+        return "%s %s %s".formatted(lhs,opType,rhs);
     }
 
     @Override
     public <S, E> E accept(IRVisitor<S, E> visitor) {
         return visitor.visit(this);
     }
+
+    public static BinExpr with(OperatorType.BinaryOpType opType,VarSlot lhs,VarSlot rhs) {
+        return new BinExpr(opType,lhs,rhs);
+    }
+
+
 }
\ No newline at end of file
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/arith/UnaryExpr.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/arith/UnaryExpr.java
index bc037a2..6e28025 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/arith/UnaryExpr.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/arith/UnaryExpr.java
@@ -2,13 +2,15 @@
 
 import org.teachfx.antlr4.ep21.ir.IRVisitor;
 import org.teachfx.antlr4.ep21.ir.expr.Expr;
+import org.teachfx.antlr4.ep21.ir.expr.VarSlot;
+import org.teachfx.antlr4.ep21.symtab.type.OperatorType;
 import org.teachfx.antlr4.ep21.symtab.type.OperatorType.UnaryOpType;
 
 public class UnaryExpr extends Expr
  {
     public UnaryOpType op;
-    public Expr expr;
-    public UnaryExpr(UnaryOpType op, Expr expr) {
+    public VarSlot expr;
+    public UnaryExpr(UnaryOpType op, VarSlot expr) {
         this.op = op;
         this.expr = expr;
     }
@@ -17,4 +19,13 @@ public UnaryExpr(UnaryOpType op, Expr expr) {
      public <S, E> E accept(IRVisitor<S, E> visitor) {
          return visitor.visit(this);
      }
+
+     public static UnaryExpr with(OperatorType.UnaryOpType opType, VarSlot operand) {
+         return new UnaryExpr(opType,operand);
+     }
+
+     @Override
+     public String toString() {
+         return "%s %s".formatted(op,expr);
+     }
  }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/val/ConstVal.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/val/ConstVal.java
new file mode 100644
index 0000000..2cf9b42
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/val/ConstVal.java
@@ -0,0 +1,42 @@
+package org.teachfx.antlr4.ep21.ir.expr.val;
+
+import org.teachfx.antlr4.ep21.ir.IRVisitor;
+import org.teachfx.antlr4.ep21.ir.expr.ImmValue;
+
+public class ConstVal<T> extends ImmValue {
+    private T val;
+
+    public ConstVal(T val) {
+        this.val = val;
+    }
+
+    public static <T> ConstVal<T> valueOf(T val) {
+        return new ConstVal<>(val);
+    }
+
+    @Override
+    public <S, E> E accept(IRVisitor<S, E> visitor) {
+        return visitor.visit(this);
+    }
+
+    public T getVal() {
+        return val;
+    }
+
+    public void setVal(T val) {
+        this.val = val;
+    }
+
+    @Override
+    public String toString() {
+        if(val instanceof String) {
+            return " '%s' ".formatted(val);
+        } else if (val instanceof Integer) {
+            return " %d ".formatted(val);
+        } else if (val instanceof Boolean) {
+            return " %b ".formatted(val);
+        }
+
+        return "val(%s)".formatted(val.toString());
+    }
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/values/BoolVal.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/values/BoolVal.java
deleted file mode 100644
index f9105c7..0000000
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/values/BoolVal.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package org.teachfx.antlr4.ep21.ir.expr.values;
-
-import org.teachfx.antlr4.ep21.ir.IRVisitor;
-import org.teachfx.antlr4.ep21.ir.expr.Expr;
-
-public class BoolVal extends Expr {
-    public boolean value;
-
-    @Override
-    public <S, E> E accept(IRVisitor<S, E> visitor) {
-        return visitor.visit(this);
-    }
-
-    public BoolVal(boolean value) {
-        this.value = value;
-    }
-
-    @Override
-    public String toString() {
-        return "BoolVal(" + value + ")";
-    }
-
-}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/values/IntVal.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/values/IntVal.java
deleted file mode 100644
index 9435b4e..0000000
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/values/IntVal.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package org.teachfx.antlr4.ep21.ir.expr.values;
-
-import org.teachfx.antlr4.ep21.ir.IRVisitor;
-import org.teachfx.antlr4.ep21.ir.expr.Expr;
-
-public class IntVal extends Expr {
-
-    public int value;
-
-    public IntVal(int value) {
-        this.value = value;
-    }
-
-    @Override
-    public String toString() {
-        return "IntVal [value=" + value + "]";
-    }
-
-    @Override
-    public int hashCode() {
-        final int prime = 31;
-        int result = 1;
-        result = prime * result + value;
-        return result;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (this == obj)
-            return true;
-        if (obj == null)
-            return false;
-        if (getClass() != obj.getClass())
-            return false;
-        IntVal other = (IntVal) obj;
-        if (value != other.value)
-            return false;
-        return true;
-    }
-
-    @Override
-    public <S, E> E accept(IRVisitor<S, E> visitor) {
-        return visitor.visit(this);
-    }
-}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/values/StringVal.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/values/StringVal.java
deleted file mode 100644
index bd8bdaa..0000000
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/values/StringVal.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package org.teachfx.antlr4.ep21.ir.expr.values;
-
-import org.teachfx.antlr4.ep21.ir.IRVisitor;
-import org.teachfx.antlr4.ep21.ir.expr.Expr;
-
-public class StringVal extends Expr {
-    public String value;
-
-
-    public StringVal(String value) {
-        this.value = value;
-    }
-
-    @Override
-    public String toString() {
-        return "StringVal [value=" + value + "]";
-    }
-
-    @Override
-    public int hashCode() {
-        final int prime = 31;
-        int result = 1;
-        result = prime * result + ((value == null) ? 0 : value.hashCode());
-        return result;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (this == obj)
-            return true;
-        if (obj == null)
-            return false;
-        if (getClass() != obj.getClass())
-            return false;
-        StringVal other = (StringVal) obj;
-        if (value == null) {
-            if (other.value != null)
-                return false;
-        } else if (!value.equals(other.value))
-            return false;
-        return true;
-    }
-
-    @Override
-    public <S, E> E accept(IRVisitor<S, E> visitor) {
-        return visitor.visit(this);
-    }
-}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/values/Var.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/values/Var.java
deleted file mode 100644
index c51e059..0000000
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/expr/values/Var.java
+++ /dev/null
@@ -1,58 +0,0 @@
-package org.teachfx.antlr4.ep21.ir.expr.values;
-
-import org.teachfx.antlr4.ep21.ast.stmt.ScopeType;
-import org.teachfx.antlr4.ep21.ir.IRVisitor;
-import org.teachfx.antlr4.ep21.ir.expr.Expr;
-import org.teachfx.antlr4.ep21.symtab.symbol.Symbol;
-
-public class Var extends Expr {
-    public Symbol symbol;
-
-    private ScopeType scopeType;
-
-    public Var(Symbol varSymbol) {
-        this.symbol = varSymbol;
-        this.scopeType = ScopeType.FuncScope;
-    }
-
-    public String getDeclName() {
-        return symbol.getName();
-    }
-
-    public Symbol getSymbol() {
-        return symbol;
-    }
-
-    public void setSymbol(Symbol symbol) {
-        this.symbol = symbol;
-    }
-
-    public ScopeType getScopeType() {
-        return scopeType;
-    }
-
-    public void setScopeType(ScopeType scopeType) {
-        this.scopeType = scopeType;
-    }
-    @Override
-    public <S, E> E accept(IRVisitor<S, E> visitor) {
-        return visitor.visit(this);
-    }
-    public String toSource(boolean isWriting) {
-        int varSlotIdx = symbol.getSlotIdx();
-        String operator = "";
-        switch ( scopeType) {
-            /// Generate all cases for scopeType
-            case ClassScope -> {
-                operator =isWriting ? "xload" : "xstore";
-            }
-            case GlobalScope -> {
-                operator = isWriting? "gload": "gstore";
-            }
-            default -> {
-                operator = isWriting? "load" : "store";
-            }
-        }
-        return String.format("%s %d", operator, varSlotIdx);
-    }
-}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/Assign.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/Assign.java
index f6b2a84..b9e5fe0 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/Assign.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/Assign.java
@@ -1,31 +1,50 @@
 package org.teachfx.antlr4.ep21.ir.stmt;
 
 import org.teachfx.antlr4.ep21.ir.IRVisitor;
-import org.teachfx.antlr4.ep21.ir.expr.Expr;
-import org.teachfx.antlr4.ep21.ir.expr.values.Var;
+import org.teachfx.antlr4.ep21.ir.expr.Operand;
+import org.teachfx.antlr4.ep21.ir.expr.VarSlot;
 
 public class Assign extends Stmt {
-    protected Var lhs;
-    protected Expr rhs;
+    protected VarSlot lhs;
+    protected Operand rhs;
 
-    public Assign(Var lhs, Expr rhs) {
+    /**
+     * Assign a value to a variable
+     * @param lhs Variable to assign
+     * @param rhs Value to assign
+     * @return Assign object
+     */
+    @SuppressWarnings("unused") // Used in generated code.
+    public static Assign with(VarSlot lhs,VarSlot rhs) {
+        return new Assign(lhs,rhs);
+    }
+    /**
+     * Assign a value to a variable
+     * @param lhs Variable to assign
+     * @param rhs Value to assign
+     * @return Assign object
+     */
+    public static Assign with(VarSlot lhs, Operand rhs) {
+        return new Assign(lhs,rhs);
+    }
+    public Assign(VarSlot lhs, Operand rhs) {
         this.lhs = lhs;
         this.rhs = rhs;
     }
 
     // Generate getter and setter for lhs and rhs
-    public Var getLhs() {
+    public VarSlot getLhs() {
         return lhs;
     }
-    public Expr getRhs() {
+    public Operand getRhs() {
         return rhs;
     }
 
-    public void setLhs(Var lhs) {
+    public void setLhs(VarSlot lhs) {
         this.lhs = lhs;
     }
 
-    public void setRhs(Expr rhs) {
+    public void setRhs(VarSlot rhs) {
         this.rhs = rhs;
     }
 
@@ -38,4 +57,9 @@ public <S, E> S accept(IRVisitor<S, E> visitor) {
     public StmtType getStmtType() {
         return StmtType.ASSIGN;
     }
+
+    @Override
+    public String toString() {
+        return "%s = %s".formatted(getLhs(),getRhs());
+    }
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/CJMP.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/CJMP.java
index 1e8d4bf..40d89fe 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/CJMP.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/CJMP.java
@@ -1,19 +1,28 @@
 package org.teachfx.antlr4.ep21.ir.stmt;
 
+import org.jetbrains.annotations.NotNull;
 import org.teachfx.antlr4.ep21.ir.IRVisitor;
-import org.teachfx.antlr4.ep21.ir.expr.Expr;
+import org.teachfx.antlr4.ep21.ir.JMPInstr;
+import org.teachfx.antlr4.ep21.ir.expr.VarSlot;
+import org.teachfx.antlr4.ep21.pass.cfg.LinearIRBlock;
 
-public class CJMP extends Stmt {
-    public Expr cond;
+public class CJMP extends Stmt implements JMPInstr {
+    public VarSlot cond;
+    private LinearIRBlock thenBlock;
+    private LinearIRBlock elseBlock;
 
-    public Label thenLabel;
-    public Label elseLabel;
 
-
-    public CJMP(Expr cond,Label thenLabel,Label elseLabel) {
+    public CJMP(@NotNull VarSlot cond, @NotNull LinearIRBlock thenLabel,@NotNull LinearIRBlock elseLabel) {
         this.cond = cond;
-        this.thenLabel = thenLabel;
-        this.elseLabel = elseLabel;
+        this.thenBlock = thenLabel;
+        this.elseBlock = elseLabel;
+        thenLabel.refJMP(this);
+        elseBlock.refJMP(this);
+    }
+
+    @Override
+    public Label getTarget() {
+        return elseBlock.getLabel();
     }
 
     @Override
@@ -25,4 +34,27 @@ public <S, E> S accept(IRVisitor<S, E> visitor) {
     public StmtType getStmtType() {
         return StmtType.CJMP;
     }
+
+    @Override
+    public String toString() {
+        return "jmpIf %s,%s,%s".formatted(cond,thenBlock,elseBlock);
+    }
+
+    public void setElseBlock(LinearIRBlock elseBlock) {
+        this.elseBlock = elseBlock;
+        elseBlock.refJMP(this);
+    }
+
+    public void setThenBlock(LinearIRBlock thenBlock) {
+        this.thenBlock = thenBlock;
+        thenBlock.refJMP(this);
+    }
+
+    public LinearIRBlock getElseBlock() {
+        return elseBlock;
+    }
+
+    public LinearIRBlock getThenBlock() {
+        return thenBlock;
+    }
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/ExprStmt.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/ExprStmt.java
index 5246f0b..39f5dec 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/ExprStmt.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/ExprStmt.java
@@ -1,27 +1,27 @@
 package org.teachfx.antlr4.ep21.ir.stmt;
 
 import org.teachfx.antlr4.ep21.ir.IRVisitor;
-import org.teachfx.antlr4.ep21.ir.expr.Expr;
+import org.teachfx.antlr4.ep21.ir.expr.VarSlot;
 
 public class ExprStmt extends Stmt {
-    private Expr expr;
-    public ExprStmt(Expr expr)
+    private VarSlot varSlot;
+    public ExprStmt(VarSlot varSlot)
     {
-        this.expr = expr;
+        this.varSlot = varSlot;
     }
 
     @Override
     public String toString()
     {
-        return expr.toString();
+        return varSlot.toString();
     }
 
-    public Expr getExpr() {
-        return expr;
+    public VarSlot getExpr() {
+        return varSlot;
     }
 
-    public void setExpr(Expr expr) {
-        this.expr = expr;
+    public void setExpr(VarSlot varSlot) {
+        this.varSlot = varSlot;
     }
 
     @Override
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/FuncEntryLabel.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/FuncEntryLabel.java
new file mode 100644
index 0000000..756e640
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/FuncEntryLabel.java
@@ -0,0 +1,21 @@
+package org.teachfx.antlr4.ep21.ir.stmt;
+
+import org.teachfx.antlr4.ep21.symtab.scope.Scope;
+
+public class FuncEntryLabel extends Label{
+
+    public FuncEntryLabel(String funcName,int args,int locals, Scope scope) {
+        super(".def %s: args=%d ,locals=%d".formatted(funcName,args,locals), scope);
+    }
+
+
+    @Override
+    public String toSource() {
+        return getRawLabel();
+    }
+
+    @Override
+    public String toString() {
+        return getRawLabel();
+    }
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/JMP.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/JMP.java
index 409d707..edc02d6 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/JMP.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/JMP.java
@@ -1,22 +1,45 @@
 package org.teachfx.antlr4.ep21.ir.stmt;
 
+import org.jetbrains.annotations.NotNull;
 import org.teachfx.antlr4.ep21.ir.IRVisitor;
+import org.teachfx.antlr4.ep21.ir.JMPInstr;
+import org.teachfx.antlr4.ep21.pass.cfg.LinearIRBlock;
 
-public class JMP extends Stmt
+public class JMP extends Stmt implements JMPInstr
 {
     @Override
     public <S, E> S accept(IRVisitor<S, E> visitor) {
         return visitor.visit(this);
     }
 
-    public JMP(Label label)
+    public JMP(@NotNull LinearIRBlock block)
     {
-        this.label = label;
+        this.next = block;
+        block.refJMP(this);
+    }
+    private LinearIRBlock next;
+
+    @Override
+    public Label getTarget() {
+        return next.getLabel();
     }
-    public Label label;
 
     @Override
     public StmtType getStmtType() {
         return StmtType.JMP;
     }
+
+    @Override
+    public String toString() {
+        return "jmp %s".formatted(next);
+    }
+
+    public void setNext(LinearIRBlock next) {
+        this.next = next;
+        next.refJMP(this);
+    }
+
+    public LinearIRBlock getNext() {
+        return this.next;
+    }
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/Label.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/Label.java
index 04c32b5..79c185c 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/Label.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/Label.java
@@ -1,14 +1,18 @@
 package org.teachfx.antlr4.ep21.ir.stmt;
 
+import org.jetbrains.annotations.NotNull;
 import org.teachfx.antlr4.ep21.ir.IRVisitor;
 import org.teachfx.antlr4.ep21.symtab.scope.Scope;
 
 import java.util.Objects;
 
-public class Label extends Stmt {
+public class Label extends Stmt implements Comparable<Label> {
+
     private Stmt nextEntry = null;
 
     private String rawLabel;
+
+
     private Scope scope;
     protected int seq;
 
@@ -20,16 +24,18 @@ public Label(String rawLabel, Scope scope) {
         }
     }
 
-    public String getRawLabel() {
-        return rawLabel;
+    public Label(Scope scope,Integer ord) {
+        this.seq = ord;
+        this.rawLabel = "L%d".formatted(seq);
+        this.scope = scope;
     }
 
-    public void setRawLabel(String rawLabel) {
-        this.rawLabel = rawLabel;
+    public Label(Scope scope) {
+        this(scope, scope.getLabelSeq());
     }
 
-    public Scope getScope() {
-        return scope;
+    public void setRawLabel(String rawLabel) {
+        this.rawLabel = rawLabel;
     }
 
     public void setScope(Scope scope) {
@@ -43,7 +49,7 @@ public <S, E> S accept(IRVisitor<S, E> visitor) {
 
     public String toSource() {
         if (Objects.nonNull(rawLabel)) {
-            return scope.getScopeName() + "_" + rawLabel ;
+            return rawLabel ;
         }
 
         return scope.getScopeName() + "_" + seq ;
@@ -59,10 +65,6 @@ public String toString() {
         return toSource();
     }
 
-    public Stmt getNextEntry() {
-        return nextEntry;
-    }
-
     public void setNextEntry(Stmt nextEntry) {
         this.nextEntry = nextEntry;
     }
@@ -80,4 +82,32 @@ public Stmt fetchNextJumpEntry() {
 
         return item;
     }
+
+    public Stmt getNextEntry() {
+        return nextEntry;
+    }
+
+    public String getRawLabel() {
+        return rawLabel;
+    }
+
+    public Scope getScope() {
+        return scope;
+    }
+
+    public int getSeq() {
+        return seq;
+    }
+
+    @Override
+    public int hashCode() {
+        return getSeq();
+    }
+
+    @Override
+    public int compareTo(@NotNull Label o) {
+        var e = Integer.valueOf(getSeq());
+        var t = Integer.valueOf(o.getSeq());
+        return e.compareTo(t);
+    }
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/ReturnVal.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/ReturnVal.java
index 24a7fa0..e4b5346 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/ReturnVal.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/ReturnVal.java
@@ -2,14 +2,16 @@
 
 
 import org.teachfx.antlr4.ep21.ir.IRVisitor;
-import org.teachfx.antlr4.ep21.ir.expr.Expr;
+import org.teachfx.antlr4.ep21.ir.expr.VarSlot;
 import org.teachfx.antlr4.ep21.symtab.scope.Scope;
 
+import java.util.Objects;
+
 public class ReturnVal extends Stmt {
     public Label retFuncLabel;
-    private Expr retVal;
+    private VarSlot retVal;
     private boolean isMainEntry = false;
-    public ReturnVal(Expr retVal, Scope scope) {
+    public ReturnVal(VarSlot retVal, Scope scope) {
         retFuncLabel = new Label(null,scope);
         retFuncLabel.setNextEntry(this);
         this.retVal = retVal;
@@ -26,11 +28,11 @@ public StmtType getStmtType() {
         return StmtType.RETURN;
     }
 
-    public Expr getRetVal() {
+    public VarSlot getRetVal() {
         return retVal;
     }
 
-    public void setRetVal(Expr retVal) {
+    public void setRetVal(VarSlot retVal) {
         this.retVal = retVal;
     }
 
@@ -41,4 +43,14 @@ public boolean isMainEntry() {
     public void setMainEntry(boolean mainEntry) {
         isMainEntry = mainEntry;
     }
+
+    @Override
+    public String toString() {
+        var retText = isMainEntry()?"halt":"ret";
+        var retValText = "";
+        if (Objects.nonNull(retVal)){
+            retValText = "load" + retVal.toString() + "\n";
+        }
+        return  retValText + retText;
+    }
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/Stmt.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/Stmt.java
index bff1354..f112a56 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/Stmt.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/ir/stmt/Stmt.java
@@ -15,4 +15,5 @@ public enum StmtType {
     public abstract <S,E> S accept(IRVisitor<S,E> visitor);
 
     public abstract StmtType getStmtType();
+
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/parser/CymbolLexer.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/parser/CymbolLexer.java
index cf74b5a..d425e5c 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/parser/CymbolLexer.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/parser/CymbolLexer.java
@@ -2,12 +2,14 @@
 
 package org.teachfx.antlr4.ep21.parser;
 
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.TokenStream;
 import org.antlr.v4.runtime.*;
-import org.antlr.v4.runtime.atn.ATN;
-import org.antlr.v4.runtime.atn.ATNDeserializer;
-import org.antlr.v4.runtime.atn.LexerATNSimulator;
-import org.antlr.v4.runtime.atn.PredictionContextCache;
+import org.antlr.v4.runtime.atn.*;
 import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.misc.*;
 
 @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
 public class CymbolLexer extends Lexer {
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/parser/CymbolParser.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/parser/CymbolParser.java
index b74a094..bb9117c 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/parser/CymbolParser.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/parser/CymbolParser.java
@@ -2,17 +2,14 @@
 
 package org.teachfx.antlr4.ep21.parser;
 
-import org.antlr.v4.runtime.*;
-import org.antlr.v4.runtime.atn.ATN;
-import org.antlr.v4.runtime.atn.ATNDeserializer;
-import org.antlr.v4.runtime.atn.ParserATNSimulator;
-import org.antlr.v4.runtime.atn.PredictionContextCache;
+import org.antlr.v4.runtime.atn.*;
 import org.antlr.v4.runtime.dfa.DFA;
-import org.antlr.v4.runtime.tree.ParseTreeListener;
-import org.antlr.v4.runtime.tree.ParseTreeVisitor;
-import org.antlr.v4.runtime.tree.TerminalNode;
-
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.misc.*;
+import org.antlr.v4.runtime.tree.*;
 import java.util.List;
+import java.util.Iterator;
+import java.util.ArrayList;
 
 @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
 public class CymbolParser extends Parser {
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/parser/Location.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/parser/Location.java
index 2076dd5..d3589d9 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/parser/Location.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/parser/Location.java
@@ -1,16 +1,13 @@
 package org.teachfx.antlr4.ep21.parser;
 
-import org.jetbrains.annotations.NotNull;
-
-
-public class Location implements Comparable<Location> {
+public class Location implements Comparable<Location>{
     protected int startLine;
     protected int startColumn;
     protected int endLine;
     protected int endColumn;
 
     public boolean hasPos() {
-        return startLine >= 0;
+        return startLine > 0;
     }
 
     public Location(int startLine,int startColumn,int endLine,int endColumn){
@@ -27,13 +24,7 @@ public String toString() {
     }
 
     @Override
-    public int compareTo(@NotNull Location o) {
-        if(startLine == o.startLine) {
-            return 0;
-        } else if (startLine > o.startLine) {
-            return 1;
-        }
-
-        return -1;
+    public int compareTo(Location o) {
+        return startLine = o.startLine;
     }
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/ast/ASTBaseVisitor.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/ast/ASTBaseVisitor.java
index 830642f..a07241f 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/ast/ASTBaseVisitor.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/ast/ASTBaseVisitor.java
@@ -113,7 +113,7 @@ public Void visit(UnaryExprNode unaryExprNode) {
 
     @Override
     public Void visit(IfStmtNode ifStmtNode) {
-        ifStmtNode.getConditionalNode().accept(this);
+        ifStmtNode.getCondExpr().accept(this);
         ifStmtNode.getThenBlock().accept(this);
 
         ifStmtNode.getElseBlock().ifPresent(block -> block.accept(this));
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/ast/CymbolASTBuilder.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/ast/CymbolASTBuilder.java
index ae27a11..bc68930 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/ast/CymbolASTBuilder.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/ast/CymbolASTBuilder.java
@@ -21,15 +21,22 @@
 
 public class CymbolASTBuilder extends CymbolBaseVisitor<ASTNode> implements CymbolVisitor<ASTNode> {
 
-    protected String srcName;
-    public CymbolASTBuilder(String srcName) {
+    public CymbolASTBuilder() {
         super();
-        this.srcName = srcName;
+
+    }
+
+    public static CymbolASTBuilder build(CymbolParser.CompilationUnitContext ctx) {
+        var astBuilder = new CymbolASTBuilder();
+
+        astBuilder.visit(ctx);
+        return astBuilder;
     }
 
+
     @Override
     public ASTNode visitCompilationUnit(CymbolParser.CompilationUnitContext ctx) {
-        var compilationUnit = new CompileUnit(srcName);
+        var compilationUnit = new CompileUnit();
         for(var childNode : ctx.children) {
             var node = visit(childNode);
             if(node instanceof VarDeclNode varDeclNode) {
@@ -47,7 +54,10 @@ public ASTNode visitVarDecl(CymbolParser.VarDeclContext ctx) {
         var typeNode = (TypeNode)visit(ctx.primaryType());
         var symbol = new VariableSymbol(ctx.ID().getText(),typeNode.getBaseType());
         var assignNode  = (ExprNode) visit(ctx.expr());
-        return new VarDeclNode(symbol,assignNode,ctx);
+        var idExprNode = new IDExprNode(ctx.ID().getText(),null);
+        idExprNode.setRefSymbol(symbol);
+
+        return new VarDeclNode(symbol,assignNode,idExprNode,ctx);
     }
 
     @Override
@@ -96,7 +106,7 @@ public ASTNode visitFormalParameter(CymbolParser.FormalParameterContext ctx) {
          TypeNode paramTypeNode = (TypeNode)visit(ctx.primaryType());
          String paramName = ctx.ID().getText();
 
-         return new VarDeclNode(new VariableSymbol(paramName, paramTypeNode.getBaseType()),null,ctx);
+         return new VarDeclNode(new VariableSymbol(paramName, paramTypeNode.getBaseType()),null,null,ctx);
     }
 
     @Override
@@ -196,6 +206,7 @@ public ASTNode visitExprFuncCall(CymbolParser.ExprFuncCallContext ctx) {
 
     @Override
     public ASTNode visitPrimaryID(CymbolParser.PrimaryIDContext ctx) {
+
         return new IDExprNode(ctx.getText(),ctx);
     }
 
@@ -211,7 +222,9 @@ public ASTNode visitPrimaryFLOAT(CymbolParser.PrimaryFLOATContext ctx) {
 
     @Override
     public ASTNode visitPrimarySTRING(CymbolParser.PrimarySTRINGContext ctx) {
-        return new StringExprNode(ctx.getText(),ctx);
+        var size = ctx.getText().length();
+
+        return new StringExprNode(ctx.getText().substring(1, size - 1),ctx);
     }
 
     @Override
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/BasicBlock.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/BasicBlock.java
index 5bf3d47..bd121a9 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/BasicBlock.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/BasicBlock.java
@@ -1,27 +1,133 @@
 package org.teachfx.antlr4.ep21.pass.cfg;
 
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
 import org.teachfx.antlr4.ep21.ir.IRNode;
+import org.teachfx.antlr4.ep21.ir.JMPInstr;
+import org.teachfx.antlr4.ep21.ir.expr.Operand;
+import org.teachfx.antlr4.ep21.ir.stmt.CJMP;
+import org.teachfx.antlr4.ep21.ir.stmt.FuncEntryLabel;
+import org.teachfx.antlr4.ep21.ir.stmt.JMP;
+import org.teachfx.antlr4.ep21.ir.stmt.Label;
+import org.teachfx.antlr4.ep21.utils.Kind;
+import org.teachfx.antlr4.ep21.utils.StreamUtils;
 
-import java.util.List;
+import java.util.*;
+import java.util.stream.Stream;
 
-public class BasicBlock {
+public class BasicBlock<I extends IRNode> implements Comparable<BasicBlock<I>>, Iterable<Loc<I>> {
 
-    List<IRNode> stmts = List.of();
+    public final int id;
+    // Generate codes
+    public List<Loc<I>> codes;
+    public Kind kind;
 
+    // For data flow analysis
+    public Set<Operand> def;
+    public Set<Operand> liveUse;
+    public Set<Operand> liveIn;
+    public Set<Operand> liveOut;
+
+    protected Label label;
+
+    public BasicBlock(Kind kind, List<Loc<I>> codes,Label label,int ord) {
+        this.codes = new ArrayList<>(codes);
+        this.label = label;
+        this.id = ord;
+        this.kind = kind;
+    }
+
+    @NotNull
+    @Contract("_ -> new")
+    public static BasicBlock<IRNode> buildFromLinearBlock(@NotNull LinearIRBlock block,List<BasicBlock<IRNode>> cachedNodes) {
+        return new BasicBlock<IRNode>(block.getKind(), block.getStmts().stream().map(Loc::new).toList(),block.getLabel(),block.getOrd());
+    }
+
+    @Override
+    public int compareTo(@NotNull BasicBlock<I> o) {
+        return this.id - o.id;
+    }
+
+    @NotNull
+    @Override
+    public Iterator<Loc<I>> iterator() {
+        return codes.iterator();
+    }
+
+    public Iterator<Loc<I>> backwardIterator() {
+        return new Iterator<Loc<I>>() {
+            private int index = codes.size() - 1;
+
+            @Override
+            public boolean hasNext() {
+                return index != -1;
+            }
+
+            @Override
+            public Loc<I> next() {
+                var loc = codes.get(index);
+                index--;
+                return loc;
+            }
+        };
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public Label getLabel() {
+        return label;
+    }
+
+    public String getOrdLabel() {
+        return "L%d".formatted(id);
+    }
+
+    // Generate isEmpty
     public boolean isEmpty() {
-        return stmts.isEmpty();
+        return codes.isEmpty();
     }
 
-    public void addStmt(IRNode stm) {
-        stmts.add(stm);
+    public List<Loc<I>> allSeq() {
+        if (kind.equals(Kind.CONTINUOUS)) {
+            return codes;
+        }
+        return codes.subList(0, codes.size() - 1);
     }
 
-    public List<IRNode> getStmts() {
-        return stmts;
+    public List<Loc<I>> dropLabelSeq() {
+        if (codes.size() <= 1) return codes;
+
+        if (codes.get(0).instr instanceof FuncEntryLabel) {
+            return codes.subList(0, codes.size());
+        }
+
+        return codes.subList(1, codes.size());
     }
 
-    // Get size of `stmts`
-    public int size() {
-        return stmts.size();
+    public I getLastInstr() {
+        return codes.get(codes.size() - 1).instr;
+    }
+
+    public void mergeNearBlock(BasicBlock<I> nextBlock) {
+        /// remove last jump instr
+        if (getLastInstr() instanceof JMPInstr) {
+            codes.remove(codes.size() - 1);
+        }
+
+        /// merge instr and update kind to use merge nextblock's kind
+        codes.addAll(nextBlock.dropLabelSeq());
+        kind = nextBlock.kind;
+    }
+
+    public void removeLastInstr() {
+        codes.remove(codes.size() - 1);
+        kind = Kind.CONTINUOUS;
+    }
+
+
+    public Stream<I> getIRNodes() {
+        return StreamUtils.flatMap(codes.stream(), Loc::getInstr);
     }
-}
+}
\ No newline at end of file
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/CFG.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/CFG.java
new file mode 100644
index 0000000..936461b
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/CFG.java
@@ -0,0 +1,158 @@
+package org.teachfx.antlr4.ep21.pass.cfg;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.commons.lang3.tuple.Triple;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.NotNull;
+import org.teachfx.antlr4.ep21.ir.IRNode;
+import org.teachfx.antlr4.ep21.utils.StreamUtils;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Stream;
+
+/*
+    One graph bind to a function.
+ */
+public class CFG<I extends IRNode> implements Iterable<BasicBlock<I>> {
+    private final static Logger logger = LogManager.getLogger(CFG.class);
+    // index: 第几号节点 -> BasicBlock<I> : 第几号节点对应的BasicBlock<I>节点
+    public final List<BasicBlock<I>> nodes;
+    // <from,to,weight> : <起始节点，终止节点,权重>
+    public final List<Triple<Integer, Integer,Integer>> edges;
+    // index: 第几号节点 ->   <prev,successors> : <前驱节点的集合，后继节点的集合>
+    private final List<Pair<Set<Integer>, Set<Integer>>> links;
+    private final List<IFlowOptimizer<I>> optimizers = new ArrayList<>();
+
+    public CFG(List<BasicBlock<I>> nodes, List<Triple<Integer, Integer,Integer>> edges) {
+        // Generate init
+        var maxOrd = nodes.stream().max(BasicBlock::compareTo).map(BasicBlock::getId).get() + 1;
+        this.nodes = nodes;
+        this.edges = edges;
+
+        links = new ArrayList<>();
+        for (var i = 0; i < maxOrd; i++) {
+            links.add(Pair.of(new TreeSet<>(), new TreeSet<>()));
+        }
+
+        for (var edge : edges) {
+            var u = edge.getLeft();
+            var v = edge.getMiddle();
+            links.get(u).getRight().add(v);
+            links.get(v).getLeft().add(u);
+        }
+    }
+
+    public BasicBlock<I> getBlock(int id) {
+        return nodes.get(id);
+    }
+
+    /**
+     * 获取前驱节点集合，也就是该节点的前驱节点集合。
+     * @param id 节点的id
+     * @return 前驱节点集合。
+     */
+    public Set<Integer> getFrontier(int id) {
+        return links.get(id).getLeft();
+    }
+
+    /**
+     * 获取后继节点集合，也就是该节点的后继节点集合。
+     * @param id 节点的id
+     * @return 后继节点集合。
+     */
+    public Set<Integer> getSucceed(int id) {
+        return links.get(id).getRight();
+    }
+
+
+    // 这个方法是用来获取节点的入度的，入度就是该节点的前驱节点的数量。
+    public int getInDegree(int id) {
+        return links.get(id).getLeft().size();
+    }
+
+
+    /*
+        @desc 这个方法是用来获取节点的入度的，入度就是该节点的前驱节点的数量。
+        @param key 节点的id
+     */
+    public Stream<Triple<Integer,Integer,Integer>> getInEdges(int key) {
+        return edges.stream().filter(edge -> edge.getMiddle() == key);
+    }
+
+    // 这个方法是用来获取节点的出度的，出度就是该节点的后继节点的数量。
+    public int getOutDegree(int id) {
+        return links.get(id).getRight().size();
+    }
+
+    @NotNull
+    @Override
+    public Iterator<BasicBlock<I>> iterator() {
+        return nodes.iterator();
+    }
+
+
+    // 写个注释
+    // 这个方法是用来生成dot文件的，这个文件可以用来生成图形的。
+    @Override
+    public String toString() {
+        var graphRenderBuffer = new StringBuilder("graph TD\n");
+        AtomicInteger i = new AtomicInteger();
+
+        for (var node : nodes.stream().sorted((b1,b2) -> b2.id - b1.id).toList()) {
+
+            graphRenderBuffer.append("subgraph ").append(node.getOrdLabel()).append("\n");
+            node.dropLabelSeq().stream().map(x -> x.instr.toString()).map(x -> "Q" + (i.getAndIncrement()) + "[\"" + x + ";\"]\n").forEach(graphRenderBuffer::append);
+            graphRenderBuffer.append("end").append("\n");
+
+        }
+
+        for (var edge : edges) {
+            graphRenderBuffer.append("L").append(edge.getLeft()).append(" --> ").append("L").append(edge.getMiddle()).append("\n");
+        }
+
+        return graphRenderBuffer.toString();
+    }
+
+
+    /**
+     * remove edge from edges and links
+     * @param edge edge to remove, Triple<Integer,Integer,Integer> : <起始节点，终止节点,权重>
+     *
+     */
+    public void removeEdge(Triple<Integer,Integer,Integer> edge) {
+        edges.remove(edge);
+        var srcBlockId = edge.getLeft();
+        var destBlockId = edge.getMiddle();
+        var nonRel = getInEdges(destBlockId).noneMatch(q -> q.getLeft().compareTo(srcBlockId) == 0);
+
+        if (nonRel) {
+            links.get(srcBlockId).getRight().remove(destBlockId);
+            links.get(destBlockId).getLeft().remove(srcBlockId);
+        }
+    }
+
+    public void removeNode(BasicBlock<I> node) {
+        /// 2. remove node from nodes by its id
+        nodes.removeIf(bb -> bb.equals(node));
+    }
+    /// 1. accept a IFlowOptimizer<I>
+    /// 2. add it to optimizers
+    public void addOptimizer(IFlowOptimizer<I> optimizer) {
+        optimizers.add(optimizer);
+    }
+
+    /// 1. apply all optimizers
+    public void applyOptimizers() {
+        // 1. apply all optimizers
+        for (var optimizer : optimizers) {
+            optimizer.onHandle(this);
+        }
+    }
+
+
+    public List<I> getIRNodes() {
+        return StreamUtils.flatMap(nodes.stream(), BasicBlock::getIRNodes).toList();
+    }
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/CFGBuilder.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/CFGBuilder.java
new file mode 100644
index 0000000..060a70a
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/CFGBuilder.java
@@ -0,0 +1,65 @@
+package org.teachfx.antlr4.ep21.pass.cfg;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.commons.lang3.tuple.Triple;
+import org.teachfx.antlr4.ep21.ir.IRNode;
+import org.teachfx.antlr4.ep21.ir.JMPInstr;
+import org.teachfx.antlr4.ep21.ir.stmt.CJMP;
+import org.teachfx.antlr4.ep21.ir.stmt.JMP;
+
+import java.util.*;
+
+public class CFGBuilder {
+    private static final Set<String> cachedEdgeLinks = new HashSet<>();
+    private final CFG<IRNode> cfg;
+    private final List<BasicBlock<IRNode>> basicBlocks;
+    private final List<Triple<Integer, Integer,Integer>> edges;
+
+    public CFGBuilder(LinearIRBlock startBlock) {
+        basicBlocks = new ArrayList<>();
+        edges = new ArrayList<>();
+
+        var cachedEdgeLink = new HashSet<String>();
+
+        build(startBlock,cachedEdgeLink);
+
+        cfg = new CFG<>(basicBlocks, edges);
+    }
+
+    private void build(LinearIRBlock block,Set<String> cachedEdgeLinks) {
+        var currentBlock = BasicBlock.buildFromLinearBlock(block,basicBlocks);
+        basicBlocks.add(currentBlock);
+        var lastInstr = block.getStmts().get(block.getStmts().size() - 1);
+        var currentOrd = block.getOrd();
+
+        if (lastInstr instanceof JMP jmp) {
+            var destOrd = jmp.getNext().getOrd();
+            var key = currentOrd + "-" + destOrd + "-" + 5;
+            if (!cachedEdgeLinks.contains(key)) {
+                cachedEdgeLinks.add(key);
+                edges.add(Triple.of(currentOrd, destOrd,5));
+            }
+        } else if (lastInstr instanceof CJMP cjmp) {
+            var elseOrd = cjmp.getElseBlock().getOrd();
+            var key = currentOrd + "-" + elseOrd + "-" + 5;
+            if (!cachedEdgeLinks.contains(key)) {
+                cachedEdgeLinks.add(key);
+                edges.add(Triple.of(currentOrd, elseOrd,5));
+            }
+        }
+
+        for (var successor : block.getSuccessors()){
+            var key = currentOrd + "-" + successor.getOrd() + "-" + 10;
+            if (!cachedEdgeLinks.contains(key)) {
+                cachedEdgeLinks.add(key);
+                edges.add(Triple.of(currentOrd, successor.getOrd(),10));
+            }
+            build(successor,cachedEdgeLinks);
+        }
+    }
+
+
+    public CFG<IRNode> getCFG() {
+        return cfg;
+    }
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/ControlFlowAnalysis.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/ControlFlowAnalysis.java
index f208965..eb28077 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/ControlFlowAnalysis.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/ControlFlowAnalysis.java
@@ -1,109 +1,69 @@
 package org.teachfx.antlr4.ep21.pass.cfg;
 
-import org.teachfx.antlr4.ep21.ir.IRVisitor;
-import org.teachfx.antlr4.ep21.ir.Prog;
-import org.teachfx.antlr4.ep21.ir.def.Func;
-import org.teachfx.antlr4.ep21.ir.expr.ArrayAccessExpr;
-import org.teachfx.antlr4.ep21.ir.expr.CallFunc;
-import org.teachfx.antlr4.ep21.ir.expr.ClassAccessExpr;
-import org.teachfx.antlr4.ep21.ir.expr.Temp;
-import org.teachfx.antlr4.ep21.ir.expr.arith.BinExpr;
-import org.teachfx.antlr4.ep21.ir.expr.arith.UnaryExpr;
-import org.teachfx.antlr4.ep21.ir.expr.values.BoolVal;
-import org.teachfx.antlr4.ep21.ir.expr.values.IntVal;
-import org.teachfx.antlr4.ep21.ir.expr.values.StringVal;
-import org.teachfx.antlr4.ep21.ir.expr.values.Var;
-import org.teachfx.antlr4.ep21.ir.stmt.*;
-
-public class ControlFlowAnalysis implements IRVisitor<Void,Void> {
-
-    @Override
-    public Void visit(IntVal node) {
-        return null;
-    }
-
-    @Override
-    public Void visit(BoolVal node) {
-        return null;
-    }
-
-    @Override
-    public Void visit(StringVal node) {
-        return null;
-    }
-
-    @Override
-    public Void visit(BinExpr node) {
-        return null;
-    }
-
-    @Override
-    public Void visit(UnaryExpr node) {
-        return null;
-    }
-
-    @Override
-    public Void visit(CallFunc callFunc) {
-        return null;
-    }
-
-    @Override
-    public Void visit(Label label) {
-        return null;
-    }
-
-    @Override
-    public Void visit(JMP jmp) {
-        return null;
-    }
-
-    @Override
-    public Void visit(CJMP cjmp) {
-        return null;
-    }
-
-    @Override
-    public Void visit(Assign assign) {
-        return null;
-    }
-
-    @Override
-    public Void visit(Func func) {
-        return null;
-    }
-
-    @Override
-    public Void visit(Var var) {
-        return null;
-    }
-
-    @Override
-    public Void visit(ClassAccessExpr classAccessExpr) {
-        return null;
-    }
-
-    @Override
-    public Void visit(ArrayAccessExpr arrayAccessExpr) {
-        return null;
-    }
-
-    @Override
-    public Void visit(ReturnVal returnVal) {
-        return null;
-    }
-
-    @Override
-    public Void visit(ExprStmt exprStmt) {
-        return null;
-    }
-
-    @Override
-    public Void visit(Prog prog) {
-        return null;
-    }
-
-    @Override
-    public Void visit(Temp temp) {
-        return null;
+import org.apache.commons.lang3.tuple.Triple;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.teachfx.antlr4.ep21.ir.IRNode;
+import org.teachfx.antlr4.ep21.ir.JMPInstr;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class ControlFlowAnalysis<I extends IRNode> implements IFlowOptimizer<I> {
+    public static Boolean DEBUG = false;
+    protected static final Logger logger = LogManager.getLogger(ControlFlowAnalysis.class);
+
+    @Override
+    public void onHandle(CFG<I> cfg) {
+        List<Triple<Integer,Integer,Integer>> needRemovedLink = new ArrayList<>();
+
+        // 1. 遍历所有的控制图的节点
+        // 2. 如果一个节点的入度为1，则该节点的前一个节点合并到该节点上
+        // 3. 如果一个节点的出度为1，并且是JMP指令同时满足JMP的next和此节点的后续相同，则该节点最后一句跳转语句应该删除。
+        // 根据上面三个条件，可以得到下面的代码
+
+        for(var block : cfg.nodes) {
+            var key = block.getId();
+            var outDeg = cfg.getOutDegree(key);
+
+            if (outDeg == 1 && block.getLastInstr() instanceof JMPInstr jmpInstr) {
+                var targetBlockId = jmpInstr.getTarget().getSeq();
+                AtomicBoolean needRemoveLastInstr = new AtomicBoolean(false);
+                cfg.getSucceed(key).stream().filter(x -> x == targetBlockId).findFirst().ifPresent(next -> {
+                    needRemoveLastInstr.set(true);
+                });
+
+                if (needRemoveLastInstr.get()) {
+                    block.removeLastInstr();
+                    cfg.removeEdge(Triple.of(key,targetBlockId, 5));
+                }
+            }
+        }
+        var removeQueue = new LinkedList<BasicBlock<I>>();
+
+        for(var block : cfg.nodes) {
+            var key = block.getId();
+
+            var inDeg = cfg.getInEdges(key).toList();
+            var isSrcSoloLink = (long) cfg.getFrontier(key).size() == 1;
+            var isDestSoloLink = isSrcSoloLink && cfg.getOutDegree(inDeg.get(0).getLeft()) == 1;
+            if (inDeg.size() == 1 && isDestSoloLink) {
+
+                cfg.getFrontier(key).stream().findFirst().ifPresent(frontier -> {
+                    var prevBlock = cfg.getBlock(frontier);
+                    prevBlock.mergeNearBlock(block);
+                    cfg.removeEdge(inDeg.get(0));
+                    removeQueue.add(block);
+                });
+
+            }
+        }
+
+        for (var block : removeQueue) {
+            cfg.removeNode(block);
+        }
     }
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/IFlowOptimizer.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/IFlowOptimizer.java
new file mode 100644
index 0000000..f9a5b3a
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/IFlowOptimizer.java
@@ -0,0 +1,7 @@
+package org.teachfx.antlr4.ep21.pass.cfg;
+
+import org.teachfx.antlr4.ep21.ir.IRNode;
+
+public interface IFlowOptimizer<I extends IRNode> {
+    public void onHandle(CFG<I> cfg);
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/IOrdIdentity.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/IOrdIdentity.java
new file mode 100644
index 0000000..7c87d9a
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/IOrdIdentity.java
@@ -0,0 +1,8 @@
+package org.teachfx.antlr4.ep21.pass.cfg;
+
+import org.jetbrains.annotations.NotNull;
+
+public interface IOrdIdentity<I> extends Comparable<IOrdIdentity<I>> {
+    I getID();
+    void setID(I id);
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/LinearIRBlock.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/LinearIRBlock.java
new file mode 100644
index 0000000..60f8f78
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/LinearIRBlock.java
@@ -0,0 +1,237 @@
+package org.teachfx.antlr4.ep21.pass.cfg;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.NotNull;
+import org.teachfx.antlr4.ep21.ir.IRNode;
+import org.teachfx.antlr4.ep21.ir.JMPInstr;
+import org.teachfx.antlr4.ep21.ir.stmt.*;
+import org.teachfx.antlr4.ep21.symtab.scope.Scope;
+import org.teachfx.antlr4.ep21.utils.Kind;
+
+import java.util.*;
+
+public class LinearIRBlock implements Comparable<LinearIRBlock> {
+
+    // Fields
+    private static int LABEL_SEQ = 0;
+    private static final Logger logger = LogManager.getLogger(LinearIRBlock.class);
+    private Kind kind = Kind.CONTINUOUS;
+    private int ord = 0;
+    private ArrayList<IRNode> stmts;
+    private List<LinearIRBlock> successors;
+    private List<LinearIRBlock> predecessors;
+
+    private Scope scope = null;
+    private List<JMPInstr> jmpRefMap = new ArrayList<>();
+
+    // Constructor
+    public LinearIRBlock(Scope scope) {
+        stmts = new ArrayList<>();
+        successors = new ArrayList<>();
+        predecessors = new ArrayList<>();
+        ord = LABEL_SEQ++;
+        this.scope = scope;
+        logger.debug(ord);
+    }
+
+    public LinearIRBlock() {
+        stmts = new ArrayList<>();
+        successors = new ArrayList<>();
+        predecessors = new ArrayList<>();
+        ord = LABEL_SEQ++;
+        this.scope = null;
+        logger.debug(ord);
+    }
+    public static boolean isBasicBlock(Stmt stmt) {
+        return !(stmt instanceof CJMP) && !(stmt instanceof JMP);
+    }
+
+    // Link Operations
+    public static void setLink(LinearIRBlock current, LinearIRBlock next) {
+        current.successors.add(next);
+        next.predecessors.add(current);
+    }
+
+    // Methods
+    // Statement Operations
+    public void addStmt(IRNode stmt) {
+        stmts.add(stmt);
+        updateKindByLastInstr(stmt);
+    }
+
+    public void insertStmt(IRNode stmt,int idx) {
+        stmts.add(idx, stmt);
+    }
+
+    private void updateKindByLastInstr(IRNode stmt) {
+        if (stmt instanceof CJMP) {
+            kind = Kind.END_BY_CJMP;
+        } else if (stmt instanceof JMP) {
+            kind = Kind.END_BY_JMP;
+        } else if (stmt instanceof ReturnVal) {
+            kind = Kind.END_BY_RETURN;
+        } else {
+            kind = Kind.CONTINUOUS;
+        }
+    }
+
+    // Getters and Setters
+    public List<IRNode> getStmts() {
+        return stmts;
+    }
+
+    public void setStmts(ArrayList<IRNode> stmts) {
+        this.stmts = stmts;
+        var lastInstr = stmts.get(stmts.size() - 1);
+        updateKindByLastInstr(lastInstr);
+    }
+
+    public List<LinearIRBlock> getSuccessors() {
+        return successors;
+    }
+
+    public void setSuccessors(List<LinearIRBlock> successors) {
+        this.successors = successors;
+    }
+
+    public List<LinearIRBlock> getPredecessors() {
+        return predecessors;
+    }
+
+    public void setPredecessors(List<LinearIRBlock> predecessors) {
+        this.predecessors = predecessors;
+    }
+
+    public Scope getScope() {
+        return scope;
+    }
+
+    public void setScope(Scope scope) {
+        this.scope = scope;
+    }
+
+    public List<JMPInstr> getJmpRefMap() {
+        return jmpRefMap;
+    }
+
+    public void setJmpRefMap(List<JMPInstr> jmpRefMap) {
+        this.jmpRefMap = jmpRefMap;
+    }
+
+    public int getOrd() {
+        return ord;
+    }
+
+    public void setLink(LinearIRBlock next) {
+        LinearIRBlock.setLink(this, next);
+    }
+
+    public Kind getKind() {
+        return kind;
+    }
+
+    // Jump Operations
+    public void refJMP(JMPInstr node) {
+        jmpRefMap.add(node);
+    }
+
+    // Utility Methods
+    @Override
+    public String toString() {
+        if (stmts.isEmpty()) {
+            return "L" + ord;
+        }
+        if (stmts.get(0) instanceof FuncEntryLabel funcEntryLabel) {
+            return funcEntryLabel.toSource();
+        }
+        return "L" + ord;
+    }
+
+    public String toSource() {
+        var firstInstr = stmts.get(0);
+
+        if (firstInstr instanceof FuncEntryLabel) {
+            return ((FuncEntryLabel) firstInstr).toSource();
+        }
+
+        return "L" + ord;
+    }
+
+    public Label getLabel() {
+        if (stmts.isEmpty()) {
+            return new Label(toString(), scope);
+        }
+
+        var firstInstr = stmts.get(0);
+        if (firstInstr instanceof Label label) {
+            return label;
+        }
+
+        return null;
+    }
+
+    public Optional<TreeSet<LinearIRBlock>> getJumpEntries() {
+        var entries = new TreeSet<LinearIRBlock>();
+        switch (kind) {
+            case END_BY_CJMP -> {
+                CJMP cjmp = (CJMP) stmts.get(stmts.size() - 1);
+                var targetLb = cjmp.getThenBlock();
+                var elseLb = cjmp.getElseBlock();
+                entries.add(targetLb);
+                entries.add(elseLb);
+                return Optional.of(entries);
+            }
+            case END_BY_JMP -> {
+                JMP cjmp = (JMP) stmts.get(stmts.size() - 1);
+                var tid = cjmp.getNext();
+                entries.add(tid);
+                return Optional.of(entries);
+            }
+            default -> {
+                return Optional.empty();
+            }
+        }
+    }
+
+    @Override
+    public int compareTo(@NotNull LinearIRBlock o) {
+        return  ord - o.getOrd();
+    }
+
+    @Override
+    public int hashCode() {
+        return (ord * 177) % 71;
+    }
+
+    /**
+     *
+     * @param otherBlock 必须是相邻的基本块才能进行合并
+     */
+    public void mergeBlock(LinearIRBlock otherBlock) {
+        stmts.addAll(otherBlock.getStmts());
+
+        updateKindByLastInstr(stmts.get(stmts.size() - 1));
+
+        setSuccessors(otherBlock.getSuccessors());
+
+        for(var s : otherBlock.getSuccessors()) {
+            s.predecessors.remove(otherBlock);
+            s.predecessors.add(this);
+        }
+
+        for (var jmp : otherBlock.getJmpRefMap()) {
+            if (jmp instanceof JMP jmpInstr) {
+                jmpInstr.setNext(this);
+            } else {
+                var jmpInstr = (CJMP) jmp;
+                jmpInstr.setElseBlock(this);
+                jmpInstr.setThenBlock(this);
+            }
+        }
+    }
+
+    public void removeSuccessor(LinearIRBlock block) {
+        successors.remove(block);
+    }
+}
\ No newline at end of file
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/LivenessAnalysis.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/LivenessAnalysis.java
new file mode 100644
index 0000000..53fc0ed
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/LivenessAnalysis.java
@@ -0,0 +1,74 @@
+package org.teachfx.antlr4.ep21.pass.cfg;
+
+import org.teachfx.antlr4.ep21.ir.IRVisitor;
+import org.teachfx.antlr4.ep21.ir.Prog;
+import org.teachfx.antlr4.ep21.ir.expr.CallFunc;
+import org.teachfx.antlr4.ep21.ir.expr.addr.FrameSlot;
+import org.teachfx.antlr4.ep21.ir.expr.addr.OperandSlot;
+import org.teachfx.antlr4.ep21.ir.expr.arith.BinExpr;
+import org.teachfx.antlr4.ep21.ir.expr.arith.UnaryExpr;
+import org.teachfx.antlr4.ep21.ir.expr.val.ConstVal;
+import org.teachfx.antlr4.ep21.ir.stmt.*;
+
+public class LivenessAnalysis implements IRVisitor<Void, Void> {
+
+    @Override
+    public Void visit(BinExpr node) {
+        return null;
+    }
+
+    @Override
+    public Void visit(UnaryExpr node) {
+        return null;
+    }
+
+    @Override
+    public Void visit(CallFunc callFunc) {
+        return null;
+    }
+
+    @Override
+    public Void visit(Label label) {
+        return null;
+    }
+
+    @Override
+    public Void visit(JMP jmp) {
+        return null;
+    }
+
+    @Override
+    public Void visit(CJMP cjmp) {
+        return null;
+    }
+
+    @Override
+    public Void visit(Assign assign) {
+        return null;
+    }
+
+    @Override
+    public Void visit(ReturnVal returnVal) {
+        return null;
+    }
+
+    @Override
+    public Void visit(Prog prog) {
+        return null;
+    }
+
+    @Override
+    public Void visit(OperandSlot operandSlot) {
+        return null;
+    }
+
+    @Override
+    public Void visit(FrameSlot frameSlot) {
+        return null;
+    }
+
+    @Override
+    public <T> Void visit(ConstVal<T> tConstVal) {
+        return null;
+    }
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/Loc.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/Loc.java
new file mode 100644
index 0000000..34cff43
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/cfg/Loc.java
@@ -0,0 +1,30 @@
+package org.teachfx.antlr4.ep21.pass.cfg;
+
+import org.teachfx.antlr4.ep21.ir.IRNode;
+import org.teachfx.antlr4.ep21.ir.expr.Operand;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Stream;
+
+public class Loc<I extends IRNode> {
+    // arrange properties
+    protected final I instr;
+    public Set<Operand> liveIn;
+    public Set<Operand> liveOut;
+
+    public Loc(I instr) {
+        this.instr = instr;
+    }
+
+    public Stream<I> getInstr() {
+        return Stream.of(instr);
+    }
+
+    @Override
+    public String toString() {
+        return "Loc{" +
+                "instr=" + instr +
+                '}';
+    }
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/codegen/CymbolAssembler.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/codegen/CymbolAssembler.java
index 9a51b9d..9ff6646 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/codegen/CymbolAssembler.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/codegen/CymbolAssembler.java
@@ -1,80 +1,45 @@
 package org.teachfx.antlr4.ep21.pass.codegen;
 
+import org.teachfx.antlr4.ep21.ir.IRNode;
 import org.teachfx.antlr4.ep21.ir.IRVisitor;
 import org.teachfx.antlr4.ep21.ir.Prog;
-import org.teachfx.antlr4.ep21.ir.def.Func;
-import org.teachfx.antlr4.ep21.ir.expr.ArrayAccessExpr;
 import org.teachfx.antlr4.ep21.ir.expr.CallFunc;
-import org.teachfx.antlr4.ep21.ir.expr.ClassAccessExpr;
-import org.teachfx.antlr4.ep21.ir.expr.Temp;
+import org.teachfx.antlr4.ep21.ir.expr.Expr;
+import org.teachfx.antlr4.ep21.ir.expr.addr.FrameSlot;
+import org.teachfx.antlr4.ep21.ir.expr.addr.OperandSlot;
 import org.teachfx.antlr4.ep21.ir.expr.arith.BinExpr;
 import org.teachfx.antlr4.ep21.ir.expr.arith.UnaryExpr;
-import org.teachfx.antlr4.ep21.ir.expr.values.BoolVal;
-import org.teachfx.antlr4.ep21.ir.expr.values.IntVal;
-import org.teachfx.antlr4.ep21.ir.expr.values.StringVal;
-import org.teachfx.antlr4.ep21.ir.expr.values.Var;
+import org.teachfx.antlr4.ep21.ir.expr.val.ConstVal;
 import org.teachfx.antlr4.ep21.ir.stmt.*;
-import org.teachfx.antlr4.ep21.symtab.symbol.MethodSymbol;
-import org.teachfx.antlr4.ep21.symtab.symbol.VariableSymbol;
-
-import java.io.*;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.Optional;
 
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
 
 public class CymbolAssembler implements IRVisitor<Void,Void> {
-    protected PrintWriter printWriter;
-    protected StringWriter stringWriter;
-
-    protected boolean emitted = false;
-
-    public CymbolAssembler() {
-        this.stringWriter = new StringWriter();
-        this.printWriter = new PrintWriter(stringWriter);
+    private LinkedList<String> assembleCmdBuffer = new LinkedList<>();
+    protected IOperatorEmitter operatorEmitter = new CymbolVMIOperatorEmitter();
+    protected void setAssembleCmdBuffer(LinkedList<String> assembleCmdBuffer) {
+        this.assembleCmdBuffer = assembleCmdBuffer;
     }
 
-    protected void emit(String str) {
-        this.printWriter.write("    %s\n".formatted(str));
+    protected LinkedList<String> getAssembleCmdBuffer() {
+        return assembleCmdBuffer;
     }
 
-    protected void emitNoPadding(String str) {
-        this.printWriter.write("%s\n".formatted(str));
+    public String getAsmInfo() {
+        return String.join("\n", assembleCmdBuffer).concat("\n");
     }
+    private int indents = 0;
 
-    public String flushCode() {
-        if(!emitted) {
-            this.printWriter.flush();
-            this.printWriter.close();
-            emitted = true;
-            return this.stringWriter.toString();
+    public Void visit(List<IRNode> linearInstrs) {
+        for (var instr: linearInstrs) {
+            if (instr instanceof Expr) {
+                ((Expr) instr).accept(this);
+            } else  {
+                ((Stmt) instr).accept(this);
+            }
         }
-
-        return this.stringWriter.toString();
-    }
-
-    @Override
-    public Void visit(Prog prog) {
-        prog.defuncList.forEach(this::visit);
-        return null;
-    }
-
-    @Override
-    public Void visit(IntVal node) {
-        emit("iconst %d".formatted(node.value));
-        return null;
-    }
-
-    @Override
-    public Void visit(BoolVal node) {
-        emit("iconst %b".formatted(node.value));
-        return null;
-    }
-
-    @Override
-    public Void visit(StringVal node) {
-        emit("sconst %s".formatted(node.value));
         return null;
     }
 
@@ -82,155 +47,109 @@ public Void visit(StringVal node) {
     public Void visit(BinExpr node) {
         node.getLhs().accept(this);
         node.getRhs().accept(this);
-        switch (node.getOpType()) {
-            case ADD -> emit("iadd");
-            case SUB -> emit("isub");
-            case MUL -> emit("imul");
-            case DIV -> emit("idiv");
-            case MOD -> emit("irem");
-            case EQ -> emit("ieq");
-            case NE -> emit("ine");
-            case LT -> emit("ilt");
-            case GT -> emit("igt");
-            case LE -> emit("ile");
-            case GE -> emit("ige");
-            case AND -> emit("iand");
-            case OR -> emit("ior");
-        }
+        emit(operatorEmitter.emitBinaryOp(node.getOpType()));
         return null;
     }
 
     @Override
     public Void visit(UnaryExpr node) {
         node.expr.accept(this);
-
-        switch (node.op) {
-            case NEG -> emit("ineg");
-            case NOT -> emit("inot");
-        }
-
+        emit(operatorEmitter.emitUnaryOp(node.op));
         return null;
     }
 
     @Override
     public Void visit(CallFunc callFunc) {
-
-        callFunc.getArgs().forEach(expr -> expr.accept(this));
-        var varDef =  callFunc.getFuncExpr();
-        var methodSymbol = (MethodSymbol) varDef.getSymbol();
-        if(!methodSymbol.isPreDefined()) {
-            emit("call %s()".formatted(varDef.getDeclName()));
+        if (!callFunc.getFuncType().isBuiltIn()){
+            emit("call %s()".formatted(callFunc.getFuncName()));
         } else {
-            emit("%s".formatted(varDef.getDeclName()));
+            emit("%s".formatted(callFunc.getFuncName()));
         }
+
         return null;
     }
 
     @Override
     public Void visit(Label label) {
-        emitNoPadding("%s :".formatted(label.toSource()));
+        // label不存在嵌套可能，下面这种情况必定是空块导致的label悬空。
+        if (indents > 0) { indents--; }
+
+        if (label instanceof FuncEntryLabel){
+            // reset indent
+            indents = 0;
+            emit("%s".formatted(label.toSource()));
+        } else {
+            emit("%s:".formatted(label.toSource()));
+        }
+        indents++;
         return null;
     }
 
     @Override
     public Void visit(JMP jmp) {
-        emit("br %s".formatted(jmp.label.toSource()));
+        emit("br %s".formatted(jmp.getNext().toString()));
+        indents--;
         return null;
     }
 
     @Override
     public Void visit(CJMP cjmp) {
-        cjmp.cond.accept(this);
-        emit("brt %s".formatted(cjmp.thenLabel.toSource()));
-        emit("br %s".formatted(cjmp.elseLabel.toSource()));
+        emit("brf %s".formatted(cjmp.getElseBlock().getLabel().toString()));
+        indents--;
         return null;
     }
 
     @Override
     public Void visit(Assign assign) {
-        var var = assign.getLhs();
-        var expr = assign.getRhs();
-        expr.accept(this);
-        emit(var.toSource(false));
-        return null;
-    }
+        assign.getRhs().accept(this);
 
-    @Override
-    public Void visit(Func func) {
-        emitNoPadding(func.toSource());
-        func.getBody().forEach(this::visit);
-        func.retHook.accept(this);
-        return null;
-    }
+        if (assign.getLhs() instanceof FrameSlot frameSlot) {
+            emit("store %d".formatted(frameSlot.getSlotIdx()));
+        }
 
-    @Override
-    public Void visit(Stmt stmt) {
-        stmt.accept(this);
         return null;
     }
 
     @Override
-    public Void visit(Var var) {
-        if(var.getSymbol() instanceof VariableSymbol) {
-            emit(var.toSource(true));
+    public Void visit(ReturnVal returnVal) {
+        if(Objects.nonNull(returnVal.getRetVal())) {
+            returnVal.getRetVal().accept(this);
         }
+        if (returnVal.isMainEntry()){
+            emit("halt");
+        } else {
+            emit("ret");
+        }
+        indents--;
         return null;
     }
 
     @Override
-    public Void visit(ArrayAccessExpr arrayAccessExpr) {
-        return null;
-    }
-
-    @Override
-    public Void visit(ClassAccessExpr classAccessExpr) {
+    public Void visit(OperandSlot operandSlot) {
         return null;
     }
 
     @Override
-    public Void visit(ReturnVal returnVal) {
-        returnVal.retFuncLabel.accept(this);
-        Optional.ofNullable(returnVal.getRetVal()).ifPresent(x -> x.accept(this));
-        if (returnVal.isMainEntry()) { emit("halt"); }
-        else { emit("ret"); }
+    public Void visit(FrameSlot frameSlot) {
+        emit("load %d".formatted(frameSlot.getSlotIdx()));
         return null;
     }
 
     @Override
-    public Void visit(ExprStmt exprStmt) {
-        exprStmt.getExpr().accept(this);
-        return null;
-    }
-
-    public void saveToFile(String filePath) throws IOException {
-        Path path = null;
-        try {
-            // 创建多级文件夹
-            path = Paths.get(filePath);
-            Files.createDirectories(path.getParent());
-            System.out.println("文件夹创建成功!");
-        } catch (IOException e) {
-            System.out.println("文件夹创建失败: " + e.getMessage());
+    public <T> Void visit(ConstVal<T> tConstVal) {
+        if (tConstVal.getVal() instanceof Integer integer) {
+            emit("iconst %d".formatted(integer));
+        } else if (tConstVal.getVal() instanceof String str) {
+            emit("sconst \"%s\"".formatted(str));
+        } else if (tConstVal.getVal() instanceof Boolean bool) {
+            emit("bconst %d".formatted(bool?1:0));
         }
 
-        if (!Files.exists(path)) {
-            Files.createFile(path);
-        }
-
-        var savedFile = new File(filePath);
-
-        if (savedFile.exists()) {
-            var os = new FileOutputStream(savedFile);
-            var osw = new OutputStreamWriter(os);
-            var pw = new PrintWriter(osw);
-            pw.write(flushCode());
-            pw.flush();
-            pw.close();
-        }
+        return null;
     }
 
-    @Override
-    public Void visit(Temp temp) {
-        return null;
+    protected void emit(String cmd) {
+        var indentCmdBuf = "    ".repeat(indents)+cmd;
+        assembleCmdBuffer.add(indentCmdBuf);
     }
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/codegen/CymbolVMIOperatorEmitter.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/codegen/CymbolVMIOperatorEmitter.java
new file mode 100644
index 0000000..00fb25c
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/codegen/CymbolVMIOperatorEmitter.java
@@ -0,0 +1,64 @@
+package org.teachfx.antlr4.ep21.pass.codegen;
+
+import org.teachfx.antlr4.ep21.symtab.type.OperatorType;
+
+public class CymbolVMIOperatorEmitter implements IOperatorEmitter {
+    @Override
+    public String emitBinaryOp(OperatorType.BinaryOpType binaryOpType) {
+        switch (binaryOpType) {
+            case ADD -> {
+                return "iadd";
+            }
+            case SUB -> {
+                return "isub";
+            }
+            case MUL -> {
+                return "imult";
+            }
+            case DIV -> {
+                return "idiv";
+            }
+            case MOD -> {
+                return "imod";
+            }
+            case NE -> {
+                return "ine";
+            }
+            case LT -> {
+                return "ilt";
+            }
+            case LE -> {
+                return "ile";
+            }
+            case EQ -> {
+                return "ieq";
+            }
+            case GT -> {
+                return "igt";
+            }
+            case GE -> {
+                return "ige";
+            }
+            case AND -> {
+                return "iand";
+            }
+            case OR -> {
+                return "ior";
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public String emitUnaryOp(OperatorType.UnaryOpType unaryOpType) {
+        switch (unaryOpType){
+            case NEG -> {
+                return "ineg";
+            }
+            case NOT -> {
+                return "inot";
+            }
+        }
+        return null;
+    }
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/codegen/IOperatorEmitter.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/codegen/IOperatorEmitter.java
new file mode 100644
index 0000000..8a73385
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/codegen/IOperatorEmitter.java
@@ -0,0 +1,9 @@
+package org.teachfx.antlr4.ep21.pass.codegen;
+
+import org.teachfx.antlr4.ep21.symtab.type.OperatorType;
+
+public interface IOperatorEmitter {
+
+    String emitBinaryOp(OperatorType.BinaryOpType binaryOpType);
+    String emitUnaryOp(OperatorType.UnaryOpType unaryOpType);
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/ir/CymbolIRBuilder.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/ir/CymbolIRBuilder.java
index 202081b..efb33e4 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/ir/CymbolIRBuilder.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/ir/CymbolIRBuilder.java
@@ -2,6 +2,7 @@
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.teachfx.antlr4.ep21.ast.ASTNode;
 import org.teachfx.antlr4.ep21.ast.ASTVisitor;
 import org.teachfx.antlr4.ep21.ast.CompileUnit;
 import org.teachfx.antlr4.ep21.ast.decl.FuncDeclNode;
@@ -9,292 +10,424 @@
 import org.teachfx.antlr4.ep21.ast.expr.*;
 import org.teachfx.antlr4.ep21.ast.stmt.*;
 import org.teachfx.antlr4.ep21.ast.type.TypeNode;
+import org.teachfx.antlr4.ep21.ir.IRNode;
 import org.teachfx.antlr4.ep21.ir.Prog;
-import org.teachfx.antlr4.ep21.ir.def.Func;
 import org.teachfx.antlr4.ep21.ir.expr.CallFunc;
-import org.teachfx.antlr4.ep21.ir.expr.Expr;
+import org.teachfx.antlr4.ep21.ir.expr.Operand;
+import org.teachfx.antlr4.ep21.ir.expr.VarSlot;
+import org.teachfx.antlr4.ep21.ir.expr.addr.FrameSlot;
+import org.teachfx.antlr4.ep21.ir.expr.addr.OperandSlot;
 import org.teachfx.antlr4.ep21.ir.expr.arith.BinExpr;
 import org.teachfx.antlr4.ep21.ir.expr.arith.UnaryExpr;
-import org.teachfx.antlr4.ep21.ir.expr.values.BoolVal;
-import org.teachfx.antlr4.ep21.ir.expr.values.IntVal;
-import org.teachfx.antlr4.ep21.ir.expr.values.StringVal;
-import org.teachfx.antlr4.ep21.ir.expr.values.Var;
+import org.teachfx.antlr4.ep21.ir.expr.val.ConstVal;
 import org.teachfx.antlr4.ep21.ir.stmt.*;
+import org.teachfx.antlr4.ep21.pass.cfg.CFG;
+import org.teachfx.antlr4.ep21.pass.cfg.CFGBuilder;
+import org.teachfx.antlr4.ep21.pass.cfg.LinearIRBlock;
+import org.teachfx.antlr4.ep21.symtab.scope.Scope;
 import org.teachfx.antlr4.ep21.symtab.symbol.MethodSymbol;
+import org.teachfx.antlr4.ep21.symtab.symbol.VariableSymbol;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 import java.util.Stack;
 
 
-public class CymbolIRBuilder implements ASTVisitor<Void, Expr> {
+public class CymbolIRBuilder implements ASTVisitor<Void, VarSlot> {
     private static final Logger logger = LogManager.getLogger(CymbolIRBuilder.class);
+    public Prog prog = null;
 
-    private final Stack<MethodSymbol> methodSymbolStack = new Stack<>();
-    public Prog root = null;
-    private Func currentFunc = null;
-    private List<Stmt> stmts;
-    private Stack<Label> breakStack;
-    private Stack<Label> continueStack;
+    private LinearIRBlock currentBlock = null;
+    private LinearIRBlock exitBlock = null;
+    private Stack<LinearIRBlock> breakStack;
+    private Stack<LinearIRBlock> continueStack;
+    private Stack<VarSlot> evalExprStack;
 
+    private ASTNode curNode = null;
     @Override
-    public Void visit(CompileUnit rootNode) {
-        root = new Prog(null);
-
-        var funcLst = rootNode.getFuncDeclarations().stream().map(this::visit);
-        funcLst.map(Func.class::cast).forEach(root::addFunc);
+    public Void visit(CompileUnit compileUnit) {
+        prog = new Prog();
+        logger.debug("visit root");
+        compileUnit.getFuncDeclarations().forEach(x -> x.accept(this));
 
         return null;
     }
 
     @Override
     public Void visit(VarDeclNode varDeclNode) {
-        if (varDeclNode.hasInitializer()) {
-            addStmt(new Assign(new Var(varDeclNode.getRefSymbol()), visit(varDeclNode.getAssignExprNode())));
+        logger.debug("visit %s".formatted(varDeclNode.toString()));
+
+        if(varDeclNode.hasInitializer()){
+            var lhsNode = (IDExprNode)varDeclNode.getIdExprNode();
+            var lhs = FrameSlot.get((VariableSymbol) lhsNode.getRefSymbol());
+            varDeclNode.getAssignExprNode().accept(this);
+            var rhs = peekEvalOperand();
+            addInstr(Assign.with(lhs,rhs));
+            popEvalOperand();
         }
         return null;
     }
 
     @Override
     public Void visit(FuncDeclNode funcDeclNode) {
-        logger.debug("enter %s".formatted(funcDeclNode.toString()));
-        methodSymbolStack.push((MethodSymbol) funcDeclNode.getRefSymbol());
-        /**/
-        stmts = new ArrayList<>();
-        /**/
-        breakStack = new Stack<>();
-        continueStack = new Stack<>();
+        logger.debug("visit %s".formatted(funcDeclNode.toString()));
 
-        currentFunc = new Func(funcDeclNode.getDeclName(), (MethodSymbol) funcDeclNode.getRefSymbol(), stmts);
+        curNode = funcDeclNode;
+        var methodSymbol = (MethodSymbol) funcDeclNode.getRefSymbol();
+        var entryLabel = new FuncEntryLabel(methodSymbol.getName(),methodSymbol.getArgs(),methodSymbol.getLocals(),methodSymbol);
+        // Expand
+        forkNewBlock(methodSymbol);
+        var startBlock = currentBlock;
 
-        setRetHook(methodSymbolStack.peek());
+        evalExprStack = new Stack<>();
+        getCurrentBlock().addStmt(entryLabel);
 
-        transformBlockStmt(funcDeclNode.getBody());
+        var exitBlock = new LinearIRBlock();
+        exitBlock.setScope(methodSymbol);
+        var exitEntry = new ReturnVal(null,methodSymbol);
 
-        currentFunc.setBody(stmts);
+        setExitHook(exitEntry,methodSymbol);
 
-        root.addFunc(currentFunc);
+        exitBlock.addStmt(exitEntry);
+        this.exitBlock = exitBlock;
 
-        methodSymbolStack.pop();
+        funcDeclNode.getBody().accept(this);
 
-        currentFunc = null;
+        prog.addBlock(startBlock);
 
-        return null;
-    }
+        setCurrentBlock(exitBlock);
 
-    private void setRetHook(MethodSymbol methodSymbol) {
-        if (methodSymbol.getName().equalsIgnoreCase("main")) {
-            var mainRet = new ReturnVal(null, methodSymbol);
-            mainRet.setMainEntry(true);
-            currentFunc.retHook = (mainRet);
-        } else {
-            var comRet = new ReturnVal(null, methodSymbol);
-            comRet.setMainEntry(false);
-            currentFunc.retHook = (comRet);
-        }
+        clearBlock();
+        return null;
     }
 
     @Override
     public Void visit(VarDeclStmtNode varDeclStmtNode) {
-        if (varDeclStmtNode.getVarDeclNode().getAssignExprNode() != null) {
+        logger.debug("visit %s".formatted(varDeclStmtNode.toString()));
+        if (varDeclStmtNode.getVarDeclNode().hasInitializer()) {
             varDeclStmtNode.getVarDeclNode().accept(this);
         }
+
         return null;
     }
 
     @Override
-    public Expr visit(TypeNode typeNode) {
+    public VarSlot visit(TypeNode typeNode) {
         return null;
     }
 
     @Override
-    public Expr visit(BinaryExprNode binaryExprNode) {
-        var lhs = (Expr) visit(binaryExprNode.getLhs());
-        var rhs = (Expr) visit(binaryExprNode.getRhs());
-        return new BinExpr(binaryExprNode.getOpType(), lhs, rhs);
-    }
+    public VarSlot visit(BinaryExprNode binaryExprNode) {
+        curNode = binaryExprNode;
 
-    @Override
-    public Expr visit(IDExprNode idExprNode) {
-        return new Var(idExprNode.getRefSymbol());
-    }
+        binaryExprNode.getLhs().accept(this);
+        var lhs = peekEvalOperand();
 
-    @Override
-    public Expr visit(BoolExprNode boolExprNode) {
-        return new BoolVal(boolExprNode.getRawValue());
+        binaryExprNode.getRhs().accept(this);
+        var rhs = peekEvalOperand();
+
+        var res = addInstr(BinExpr.with(binaryExprNode.getOpType(),lhs,rhs));
+
+        res.ifPresent(this::pushEvalOperand);
+
+        return null;
     }
 
     @Override
-    public Expr visit(IntExprNode intExprNode) {
-        // generate IntVal from intExprNode
-        return new IntVal(intExprNode.getRawValue());
+    public VarSlot visit(UnaryExprNode unaryExprNode) {
+        curNode = unaryExprNode;
+        unaryExprNode.getValExpr().accept(this);
+        var expr = peekEvalOperand();
+        var res = addInstr(UnaryExpr.with(unaryExprNode.getOpType(),expr));
+        res.ifPresent(this::pushEvalOperand);
+
+        return null;
     }
 
     @Override
-    public Expr visit(FloatExprNode floatExprNode) {
-        return new IntVal(floatExprNode.getRawValue().intValue());
+    public VarSlot visit(IDExprNode idExprNode) {
+        curNode = idExprNode;
+
+        if (idExprNode.getRefSymbol() instanceof VariableSymbol) {
+            var varSlot = FrameSlot.get((VariableSymbol) idExprNode.getRefSymbol());
+
+            if(!idExprNode.isLValue()) {
+                // RVal
+                pushEvalOperand(varSlot);
+            }
+        }
+        return null;
     }
 
     @Override
-    public Expr visit(NullExprNode nullExprNode) {
+    public VarSlot visit(BoolExprNode boolExprNode) {
+
+        pushEvalOperand( ConstVal.valueOf(boolExprNode.getRawValue()));
+
         return null;
     }
-
     @Override
-    public Expr visit(StringExprNode stringExprNode) {
-        return new StringVal(stringExprNode.getRawValue());
+    public VarSlot visit(IntExprNode intExprNode) {
+        pushEvalOperand(ConstVal.valueOf(intExprNode.getRawValue()));
+        return null;
     }
 
     @Override
-    public Expr visit(UnaryExprNode unaryExprNode) {
-        var expr = (Expr) visit(unaryExprNode.getValExpr());
-        return new UnaryExpr(unaryExprNode.getOpType(), expr);
+    public VarSlot visit(FloatExprNode floatExprNode) {
+        pushEvalOperand(ConstVal.valueOf(floatExprNode.getRawValue()));
+        return null;
     }
 
     @Override
-    public Expr visit(CallFuncNode callExprNode) {
-        var args = callExprNode.getArgsNode().stream().map(this::visit).map(Expr.class::cast).toList();
-        return new CallFunc(new Var(callExprNode.getCallFuncSymbol()), args);
+    public VarSlot visit(NullExprNode nullExprNode) {
+        pushEvalOperand(ConstVal.valueOf(nullExprNode.getRawValue()));
+        return null;
     }
 
     @Override
-    public Void visit(IfStmtNode ifStmtNode) {
-        var thenLabel = new Label(null, ifStmtNode.getScope());
-        var elseLabel = new Label(null, ifStmtNode.getScope());
-        var endLabel = new Label(null, ifStmtNode.getScope());
-
-        var condExpr = (Expr) visit(ifStmtNode.getConditionalNode());
-        var hasElseBranch = ifStmtNode.getElseBlock().isPresent();
-        var thenSuccLabel = hasElseBranch ? elseLabel : endLabel;
-
-        cjump(condExpr, thenLabel, thenSuccLabel);
-        label(thenLabel);
-
-        ifStmtNode.getThenBlock().accept(this);
-
-        if (hasElseBranch) jump(endLabel);
-
-        if (hasElseBranch) {
-            label(elseLabel);
-            ifStmtNode.getElseBlock().ifPresent(this::transformBlockStmt);
-        }
-
-        /// Label local
-        label(endLabel);
-
+    public VarSlot visit(StringExprNode stringExprNode) {
+        pushEvalOperand(ConstVal.valueOf(stringExprNode.getRawValue()));
         return null;
     }
 
-    protected void transformBlockStmt(StmtNode blockStmt) {
-        blockStmt.accept(this);
+    @Override
+    public VarSlot visit(CallFuncNode callExprNode) {
+        curNode = callExprNode;
+        var methodSymbol = callExprNode.getCallFuncSymbol();
+        var funcName = callExprNode.getFuncName();
+        var args = callExprNode.getArgsNode().size();
+        callExprNode.getArgsNode().forEach(x -> x.accept(this));
+        addInstr(new CallFunc(funcName,args,methodSymbol));
+        return null;
     }
 
     @Override
     public Void visit(ExprStmtNode exprStmtNode) {
-        addStmt(new ExprStmt(visit(exprStmtNode.getExprNode())));
+        curNode = exprStmtNode;
+        exprStmtNode.getExprNode().accept(this);
         return null;
     }
 
+    @Override
+    public Void visit(BlockStmtNode blockStmtNode) {
+        curNode = blockStmtNode;
+        blockStmtNode.getStmtNodes().forEach(x -> x.accept(this));
+        return null;
+    }
 
     @Override
     public Void visit(ReturnStmtNode returnStmtNode) {
-        var retVal = (Expr) visit(returnStmtNode.getRetNode());
-        addStmt(new ExprStmt(retVal));
-        jump(currentFuncExitEntry());
+        curNode = returnStmtNode;
+        if (returnStmtNode.getRetNode() != null) {
+            returnStmtNode.getRetNode().accept(this);
+            popEvalOperand();
+        }
+
+        jump(exitBlock);
         return null;
     }
 
     @Override
     public Void visit(WhileStmtNode whileStmtNode) {
-        var beginLabel = new Label(null, whileStmtNode.getScope());
-        var thenLabel = new Label(null, whileStmtNode.getScope());
-        var endLabel = new Label(null, whileStmtNode.getScope());
+        curNode = whileStmtNode;
+        var condBlock = new LinearIRBlock(currentBlock.getScope());
+        var doBlock = new LinearIRBlock(currentBlock.getScope());
+        var endBlock = new LinearIRBlock(currentBlock.getScope());
+
+        jump(condBlock);
+
+        pushBreakStack(endBlock);
+        pushContinueStack(condBlock);
+
+        setCurrentBlock(condBlock);
+        whileStmtNode.getConditionNode().accept(this);
 
-        pushBreakTarget(endLabel);
-        pushContinueTarget(beginLabel);
+        var cond = peekEvalOperand();
 
-        var condExpr = (Expr) visit(whileStmtNode.getConditionNode());
-        label(beginLabel);
-        cjump(condExpr, thenLabel, endLabel);
-        label(thenLabel);
-        transformBlockStmt(whileStmtNode.getBlockNode());
-        jump(beginLabel);
+        jumpIf(cond,doBlock,endBlock);
 
-        label(endLabel);
+        setCurrentBlock(doBlock);
+        whileStmtNode.getBlockNode().accept(this);
+        jump(condBlock);
 
-        popBreakTarget();
-        popContinueTarget();
+        popBreakStack();
+        popContinueStack();
+
+        setCurrentBlock(endBlock);
+        return null;
+    }
+
+    @Override
+    public Void visit(IfStmtNode ifStmtNode) {
+        curNode = ifStmtNode;
+
+        ifStmtNode.getCondExpr().accept(this);
+        var cond = peekEvalOperand();
+        var thenBlock = new LinearIRBlock(currentBlock.getScope());
+        var endBlock = new LinearIRBlock(currentBlock.getScope());
+
+        if (ifStmtNode.getElseBlock().isEmpty()) {
+            jumpIf(cond,thenBlock,endBlock);
+            setCurrentBlock(thenBlock);
+            ifStmtNode.getThenBlock().accept(this);
+        }else {
+            var elseBlock = new LinearIRBlock(currentBlock.getScope());
+            jumpIf(cond,thenBlock,elseBlock);
+            setCurrentBlock(thenBlock);
+            ifStmtNode.getThenBlock().accept(this);
+            setCurrentBlock(elseBlock);
+            ifStmtNode.getElseBlock().ifPresent(x -> x.accept(this));
+        }
 
+        setCurrentBlock(endBlock);
         return null;
     }
 
     @Override
     public Void visit(AssignStmtNode assignStmtNode) {
-        addStmt(new Assign((Var) visit(assignStmtNode.getLhs()), visit(assignStmtNode.getRhs())));
+        curNode = assignStmtNode;
+        assignStmtNode.getRhs().accept(this);
+        var rhs = peekEvalOperand();
+        var lhsNode = (IDExprNode) assignStmtNode.getLhs();
+        var lhs = FrameSlot.get((VariableSymbol) lhsNode.getRefSymbol());
+        addInstr(Assign.with(lhs,rhs));
+        popEvalOperand();
         return null;
     }
 
     @Override
     public Void visit(BreakStmtNode breakStmtNode) {
-        addStmt(new JMP(currentBreakTarget()));
+        curNode = breakStmtNode;
+        jump(breakStack.peek());
+
         return null;
     }
 
     @Override
     public Void visit(ContinueStmtNode continueStmtNode) {
-        addStmt(new JMP(currentContinueTarget()));
+        curNode = continueStmtNode;
+        jump(continueStack.peek());
+
         return null;
     }
 
-    @Override
-    public Void visit(BlockStmtNode blockStmtNode) {
-        Optional.ofNullable(blockStmtNode.getStmtNodes()).ifPresent(stmtNodes -> stmtNodes.forEach(this::transformBlockStmt));
+    public void forkNewBlock(Scope scope) {
+        currentBlock = new LinearIRBlock();
+        currentBlock.setScope(scope);
+        breakStack = new Stack<>();
+        continueStack = new Stack<>();
+    }
+    public void clearBlock() {
+        currentBlock = null;
+    }
 
-        return null;
+    protected LinearIRBlock getCurrentBlock() {
+        return currentBlock;
     }
 
-    protected void addStmt(Stmt stmt) {
-        stmts.add(stmt);
+    public void setCurrentBlock(LinearIRBlock nextBlock) {
+        currentBlock.setLink(nextBlock);
+        currentBlock = nextBlock;
     }
 
-    protected void jump(Label thenLabel) {
-        addStmt(new JMP(thenLabel));
+
+    public Optional<VarSlot> addInstr(IRNode stmt) {
+
+        getCurrentBlock().addStmt(stmt);
+        if (stmt instanceof BinExpr) {
+            popEvalOperand();
+            popEvalOperand();
+            return Optional.of(OperandSlot.pushStack());
+        } else if (stmt instanceof UnaryExpr) {
+            popEvalOperand();
+            return Optional.of(OperandSlot.pushStack());
+        } else if(stmt instanceof CJMP) {
+            popEvalOperand();
+        } else if (stmt instanceof CallFunc callFunc) {
+            int i = callFunc.getArgs();
+
+            while (i > 0){
+                popEvalOperand();
+                i--;
+            }
+            // 如果存在返回值，则要模拟压入返回值以保证栈平衡
+            if(!callFunc.getFuncType().isVoid()) {
+               pushEvalOperand(OperandSlot.genTemp());
+            }
+        }
+
+        return Optional.empty();
     }
 
-    protected void label(Label label) {
-        addStmt(label);
+    protected void setExitHook(ReturnVal returnVal,MethodSymbol methodSymbol) {
+        if (methodSymbol.getName().equalsIgnoreCase("main")) {
+            returnVal.setMainEntry(true);
+        }
     }
 
-    protected void cjump(Expr cond, Label thenLabel, Label elseLabel) {
-        addStmt(new CJMP(cond, thenLabel, elseLabel));
+    public void jump(LinearIRBlock block) {
+        addInstr(new JMP(block));
+    }
+    public void jumpIf(VarSlot cond, LinearIRBlock thenBlock, LinearIRBlock elseBlock) {
+        addInstr(new CJMP(cond,thenBlock,elseBlock));
+    }
+    public void pushBreakStack(LinearIRBlock linearIRBlock) {
+        breakStack.push(linearIRBlock);
     }
 
-    protected Label currentBreakTarget() {
-        return breakStack.peek();
+    public void popBreakStack() {
+        breakStack.pop();
     }
 
-    private Label currentContinueTarget() {
-        return continueStack.peek();
+
+    public void pushContinueStack(LinearIRBlock linearIRBlock) {
+        continueStack.push(linearIRBlock);
     }
 
-    protected void pushBreakTarget(Label label) {
-        breakStack.push(label);
+
+    public void popContinueStack() {
+        continueStack.pop();
     }
+    static int cnt = 0;
+    protected VarSlot pushEvalOperand(Operand operand) {
+
+        if (curNode != null) {
+            logger.debug(curNode.toString());
+        }
+
+        if (!(operand instanceof OperandSlot)){
+            cnt++;
+            var assignee = OperandSlot.pushStack();
+            evalExprStack.push(assignee);
+            addInstr(Assign.with(assignee, operand));
+            logger.debug("-> eval stack %s%n", evalExprStack.toString());
+
+            return assignee;
+        } else {
+            logger.debug("-> eval stack %s%n", evalExprStack.toString());
+            evalExprStack.push((VarSlot) operand);
+            return (VarSlot) operand;
+        }
 
-    protected void pushContinueTarget(Label label) {
-        continueStack.push(label);
     }
 
-    protected void popBreakTarget() {
-        breakStack.pop();
+    protected VarSlot popEvalOperand() {
+        var res = evalExprStack.pop();
+        logger.debug("pop eval operand %s",res);
+        logger.debug("pop stack");
+        OperandSlot.popStack();
+        if (OperandSlot.getOrdSeq() < 0) {
+            throw new RuntimeException("un matched pop");
+        }
+        return res;
     }
 
-    protected void popContinueTarget() {
-        continueStack.pop();
+    protected VarSlot peekEvalOperand() {
+        return evalExprStack.peek();
     }
 
-    protected Label currentFuncExitEntry() {
-        return currentFunc.retHook.retFuncLabel;
+    public CFG<IRNode> getCFG(LinearIRBlock startBlocks) {
+        var cfgBuilder = new CFGBuilder(startBlocks);
+        return cfgBuilder.getCFG();
     }
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/sematic/TypeChecker.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/sematic/TypeChecker.java
index 6c87944..85df1db 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/sematic/TypeChecker.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/pass/sematic/TypeChecker.java
@@ -21,6 +21,9 @@ public Void visit(IDExprNode idExprNode) {
 
     @Override
     public Void visit(VarDeclNode varDeclNode) {
+        if(varDeclNode.hasInitializer()) {
+            varDeclNode.getIdExprNode().setLValue(true);
+        }
         return super.visit(varDeclNode);
     }
 
@@ -31,6 +34,7 @@ public Void visit(FuncDeclNode funcDeclNode) {
 
     @Override
     public Void visit(VarDeclStmtNode varDeclStmtNode) {
+        varDeclStmtNode.getVarDeclNode().accept(this);
         return super.visit(varDeclStmtNode);
     }
 
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/symtab/symbol/MethodSymbol.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/symtab/symbol/MethodSymbol.java
index 3ebf040..42f1803 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/symtab/symbol/MethodSymbol.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/symtab/symbol/MethodSymbol.java
@@ -60,6 +60,11 @@ public Type getFuncType() {
         return this;
     }
 
+    @Override
+    public boolean isVoid() {
+        return getReturnType().isVoid();
+    }
+
     @Override
     public Type getPrimitiveType() {
         return null;
@@ -90,7 +95,9 @@ public int setBaseVarSlotSeq(int baseVarSlotSeq) {
     public int getVarSlots() {
         return getMembers().size();
     }
-
+    public int getLocals() {
+        return  getVarSlots() - getArgs();
+    }
     @Override
     public boolean isBuiltIn() {
         return builtIn;
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/symtab/type/BuiltInTypeSymbol.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/symtab/type/BuiltInTypeSymbol.java
index 84a3913..36f6546 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/symtab/type/BuiltInTypeSymbol.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/symtab/type/BuiltInTypeSymbol.java
@@ -33,4 +33,8 @@ public Type getPrimitiveType() {
         return this;
     }
 
+    @Override
+    public boolean isVoid() {
+        return name.equalsIgnoreCase("void");
+    }
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/symtab/type/Type.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/symtab/type/Type.java
index ff0dabd..a84a74b 100644
--- a/ep21/src/main/java/org/teachfx/antlr4/ep21/symtab/type/Type.java
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/symtab/type/Type.java
@@ -10,5 +10,5 @@ public interface Type {
     public Type getFuncType();
     public Type getPrimitiveType();
 
-
+    public boolean isVoid();
 }
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/utils/Kind.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/utils/Kind.java
new file mode 100644
index 0000000..0bafa08
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/utils/Kind.java
@@ -0,0 +1,12 @@
+package org.teachfx.antlr4.ep21.utils;
+
+public enum Kind {
+    /// No jump instruction
+    CONTINUOUS,
+    /// Conditional instruction
+    END_BY_CJMP,
+    /// Unconditional jump instruction
+    END_BY_JMP,
+    /// Return instruction
+    END_BY_RETURN
+}
diff --git a/ep21/src/main/java/org/teachfx/antlr4/ep21/utils/StreamUtils.java b/ep21/src/main/java/org/teachfx/antlr4/ep21/utils/StreamUtils.java
new file mode 100644
index 0000000..59b938b
--- /dev/null
+++ b/ep21/src/main/java/org/teachfx/antlr4/ep21/utils/StreamUtils.java
@@ -0,0 +1,41 @@
+package org.teachfx.antlr4.ep21.utils;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+public class StreamUtils {
+    public static <T> Stream<? super Pair<Integer, T>> mapWithIndex(Stream<T> stream,Function<? super Pair<Integer, T>,? super Pair<Integer, T>> mapper) {
+        AtomicInteger cnt = new AtomicInteger();
+        return stream.map(s -> Pair.of( cnt.getAndIncrement(),s)).map(mapper);
+    }
+
+    public static <T> Stream<Pair<Integer,T>> indexStream(Stream<T> stream) {
+        AtomicInteger cnt = new AtomicInteger();
+        return stream.map(s -> Pair.of(cnt.getAndIncrement(),s));
+    }
+
+    public static <T> int indexOf(Stream<T> stream, Predicate<T> predicate) {
+       return (int) StreamUtils.indexStream(stream).filter(tIntegerPair ->
+            predicate.test(tIntegerPair.getRight())
+        ).findFirst().map(Pair::getLeft).orElse(-1);
+    }
+    // find matched object
+    public static <T> T find(Stream<T> stream, Predicate<T> predicate) {
+        return stream.filter(predicate).findFirst().orElse(null);
+    }
+
+    // remove if find any matched object
+    public static <T> Stream<T> removeIf(Stream<T> stream, Predicate<T> predicate) {
+        return stream.filter(predicate.negate());
+    }
+    // generate code for flatmap
+    public static <T, R> Stream<R> flatMap(Stream<T> stream, Function<T, Stream<R>> mapper) {
+        return stream.flatMap(mapper);
+    }
+}
+
+
diff --git a/ep21/src/main/resources/graph_0_optimized.md b/ep21/src/main/resources/graph_0_optimized.md
new file mode 100644
index 0000000..23c5c3c
--- /dev/null
+++ b/ep21/src/main/resources/graph_0_optimized.md
@@ -0,0 +1,11 @@
+```mermaid
+graph TD
+subgraph L0
+Q0[".def dec1: args=1 ,locals=1;"]
+Q1["t0 = @0;"]
+Q2["t1 =  1 ;"]
+Q3["t0 SUB t1;"]
+Q4["ret;"]
+end
+
+```
diff --git a/ep21/src/main/resources/graph_0_origin.md b/ep21/src/main/resources/graph_0_origin.md
new file mode 100644
index 0000000..2fd1d7f
--- /dev/null
+++ b/ep21/src/main/resources/graph_0_origin.md
@@ -0,0 +1,16 @@
+```mermaid
+graph TD
+subgraph L1
+Q0["ret;"]
+end
+subgraph L0
+Q1[".def dec1: args=1 ,locals=1;"]
+Q2["t0 = @0;"]
+Q3["t1 =  1 ;"]
+Q4["t0 SUB t1;"]
+Q5["jmp L1;"]
+end
+L0 --> L1
+L0 --> L1
+
+```
diff --git a/ep21/src/main/resources/graph_1_optimized.md b/ep21/src/main/resources/graph_1_optimized.md
new file mode 100644
index 0000000..6db8206
--- /dev/null
+++ b/ep21/src/main/resources/graph_1_optimized.md
@@ -0,0 +1,59 @@
+```mermaid
+graph TD
+subgraph L9
+Q0["t0 =  7 ;"]
+Q1["jmp L3;"]
+end
+subgraph L8
+Q2["t0 =  'break' ;"]
+Q3["call print(args:1);"]
+Q4["t0 = @0;"]
+Q5["call dec1(args:1);"]
+Q6["@0 = t0;"]
+Q7["jmp L4;"]
+end
+subgraph L7
+Q8["t0 = @0;"]
+Q9["call print(args:1);"]
+Q10["t0 = @0;"]
+Q11["t1 =  7 ;"]
+Q12["t0 EQ t1;"]
+Q13["jmpIf t0,L9,L8;"]
+end
+subgraph L6
+Q14["t0 =  0 ;"]
+end
+subgraph L5
+Q15["t0 = @0;"]
+Q16["t1 =  5 ;"]
+Q17["t0 GT t1;"]
+Q18["jmpIf t0,L7,L8;"]
+end
+subgraph L4
+Q19["t0 = @0;"]
+Q20["t1 =  0 ;"]
+Q21["t0 GT t1;"]
+Q22["jmpIf t0,L5,L6;"]
+end
+subgraph L3
+Q23["halt;"]
+end
+subgraph L2
+Q24[".def main: args=0 ,locals=1;"]
+Q25["t0 =  10 ;"]
+Q26["@0 = t0;"]
+end
+L2 --> L4
+L4 --> L6
+L4 --> L5
+L5 --> L8
+L5 --> L7
+L7 --> L8
+L7 --> L9
+L9 --> L3
+L9 --> L8
+L8 --> L4
+L8 --> L6
+L6 --> L3
+
+```
diff --git a/ep21/src/main/resources/graph_1_origin.md b/ep21/src/main/resources/graph_1_origin.md
new file mode 100644
index 0000000..50cf9d3
--- /dev/null
+++ b/ep21/src/main/resources/graph_1_origin.md
@@ -0,0 +1,63 @@
+```mermaid
+graph TD
+subgraph L9
+Q0["t0 =  7 ;"]
+Q1["jmp L3;"]
+end
+subgraph L8
+Q2["t0 =  'break' ;"]
+Q3["call print(args:1);"]
+Q4["t0 = @0;"]
+Q5["call dec1(args:1);"]
+Q6["@0 = t0;"]
+Q7["jmp L4;"]
+end
+subgraph L7
+Q8["t0 = @0;"]
+Q9["call print(args:1);"]
+Q10["t0 = @0;"]
+Q11["t1 =  7 ;"]
+Q12["t0 EQ t1;"]
+Q13["jmpIf t0,L9,L8;"]
+end
+subgraph L6
+Q14["t0 =  0 ;"]
+Q15["jmp L3;"]
+end
+subgraph L5
+Q16["t0 = @0;"]
+Q17["t1 =  5 ;"]
+Q18["t0 GT t1;"]
+Q19["jmpIf t0,L7,L8;"]
+end
+subgraph L4
+Q20["t0 = @0;"]
+Q21["t1 =  0 ;"]
+Q22["t0 GT t1;"]
+Q23["jmpIf t0,L5,L6;"]
+end
+subgraph L3
+Q24["halt;"]
+end
+subgraph L2
+Q25[".def main: args=0 ,locals=1;"]
+Q26["t0 =  10 ;"]
+Q27["@0 = t0;"]
+Q28["jmp L4;"]
+end
+L2 --> L4
+L2 --> L4
+L4 --> L6
+L4 --> L5
+L5 --> L8
+L5 --> L7
+L7 --> L8
+L7 --> L9
+L9 --> L3
+L9 --> L8
+L8 --> L4
+L8 --> L6
+L6 --> L3
+L6 --> L3
+
+```
diff --git a/ep21/src/main/resources/log4j2.xml b/ep21/src/main/resources/log4j2.xml
index 35a6a3c..db002c3 100644
--- a/ep21/src/main/resources/log4j2.xml
+++ b/ep21/src/main/resources/log4j2.xml
@@ -1,9 +1,12 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<Configuration status="WARN">
+<Configuration status="INFO">
     <Appenders>
         <Console name="Console" target="SYSTEM_OUT">
             <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
         </Console>
+        <File name="File" fileName="logs/app.log">
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
+        </File>
     </Appenders>
     <Loggers>
         <Root level="info">
diff --git a/ep21/src/main/resources/t.cymbol b/ep21/src/main/resources/t.cymbol
index d30549e..963232b 100644
--- a/ep21/src/main/resources/t.cymbol
+++ b/ep21/src/main/resources/t.cymbol
@@ -1,25 +1,23 @@
-/*
-int fib(int n){
-    int p = 1;
-    int q = 1;
-    while(p <= 100) {
-        if (p >= 1) {
-            p = p*2 + 1;
-            if (q <= p / 2) {
-                return p;
-            }
-        } else {
-            return q;
-        }
-    }
 
-    return p;
+int dec1(int x) {
+    return x - 1;
 }
-*/
 
 int main() {
+    int i = 10;
+    while(i > 0) {
+        if (i > 5) {
+            print(i);
+            if(i == 7) {
+                return 7;
+            }
+        }
+
+        print("break");
+
+        i = dec1(i);
+    }
 
-   print(10);
    return 0;
 }
 
diff --git a/ep21/src/main/resources/t.vm b/ep21/src/main/resources/t.vm
deleted file mode 100644
index 640828f..0000000
--- a/ep21/src/main/resources/t.vm
+++ /dev/null
@@ -1,7 +0,0 @@
-.def main: args=0 ,locals=0
-    iconst 10
-    print
-    iconst 0
-    br main_0
-main_0 :
-    halt
diff --git a/ep21/src/test/java/org/teachfx/antlr4/ep21/ast/expr/BoolExprNodeTest.java b/ep21/src/test/java/org/teachfx/antlr4/ep21/ast/expr/BoolExprNodeTest.java
index 531ae0b..1605423 100644
--- a/ep21/src/test/java/org/teachfx/antlr4/ep21/ast/expr/BoolExprNodeTest.java
+++ b/ep21/src/test/java/org/teachfx/antlr4/ep21/ast/expr/BoolExprNodeTest.java
@@ -1,14 +1,3 @@
 package org.teachfx.antlr4.ep21.ast.expr;
-
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-class BoolExprNodeTest {
-
-    @Test
-    void testToString() {
-        var boolVal = new BoolExprNode(true,null);
-        assertEquals("true",boolVal.getRawValue().toString());
-    }
-}
\ No newline at end of file
+public class BoolExprNodeTest {
+}
diff --git a/ep21/src/test/java/org/teachfx/antlr4/ep21/ast/expr/FloatExprNodeTest.java b/ep21/src/test/java/org/teachfx/antlr4/ep21/ast/expr/FloatExprNodeTest.java
deleted file mode 100644
index a749797..0000000
--- a/ep21/src/test/java/org/teachfx/antlr4/ep21/ast/expr/FloatExprNodeTest.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package org.teachfx.antlr4.ep21.ast.expr;
-
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-class FloatExprNodeTest {
-    @Test
-    void floatRawExtract() {
-
-        var node = new FloatExprNode(1.2,null);
-        assertEquals((double) 1.2, node.getRawValue());
-    }
-
-
-}
\ No newline at end of file
diff --git a/ep21/src/test/java/org/teachfx/antlr4/ep21/ast/expr/StringExprNodeTest.java b/ep21/src/test/java/org/teachfx/antlr4/ep21/ast/expr/StringExprNodeTest.java
deleted file mode 100644
index 4615307..0000000
--- a/ep21/src/test/java/org/teachfx/antlr4/ep21/ast/expr/StringExprNodeTest.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package org.teachfx.antlr4.ep21.ast.expr;
-
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-class StringExprNodeTest {
-
-    @Test
-    void testRawVal() {
-        var strNode = new StringExprNode("Hello",null);
-        assertEquals("Hello",strNode.getRawValue());
-    }
-}
\ No newline at end of file
diff --git a/ep21/src/test/java/org/teachfx/antlr4/ep21/ast/expr/UnaryExprNodeTest.java b/ep21/src/test/java/org/teachfx/antlr4/ep21/ast/expr/UnaryExprNodeTest.java
deleted file mode 100644
index d2b241e..0000000
--- a/ep21/src/test/java/org/teachfx/antlr4/ep21/ast/expr/UnaryExprNodeTest.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package org.teachfx.antlr4.ep21.ast.expr;
-
-import org.junit.jupiter.api.Test;
-import org.teachfx.antlr4.ep21.symtab.type.OperatorType;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-class UnaryExprNodeTest {
-    @Test
-    public void testNegInt() {
-        var node = new UnaryExprNode(OperatorType.UnaryOpType.NEG, new IntExprNode(1, null),null);
-
-        assertEquals(node.getOpType(),OperatorType.UnaryOpType.NEG);
-        assertEquals(node.getValExpr(), new IntExprNode(1, null));
-    }
-}
\ No newline at end of file
diff --git a/ep21/src/test/java/org/teachfx/antlr4/ep21/pass/cfg/BasicBlockTest.java b/ep21/src/test/java/org/teachfx/antlr4/ep21/pass/cfg/BasicBlockTest.java
new file mode 100644
index 0000000..5c29817
--- /dev/null
+++ b/ep21/src/test/java/org/teachfx/antlr4/ep21/pass/cfg/BasicBlockTest.java
@@ -0,0 +1,135 @@
+package org.teachfx.antlr4.ep21.pass.cfg;
+
+import org.junit.jupiter.api.Test;
+import org.teachfx.antlr4.ep21.ir.IRNode;
+import org.teachfx.antlr4.ep21.ir.expr.ImmValue;
+import org.teachfx.antlr4.ep21.ir.expr.VarSlot;
+import org.teachfx.antlr4.ep21.ir.expr.addr.FrameSlot;
+import org.teachfx.antlr4.ep21.ir.expr.arith.BinExpr;
+import org.teachfx.antlr4.ep21.ir.expr.val.ConstVal;
+import org.teachfx.antlr4.ep21.ir.stmt.CJMP;
+import org.teachfx.antlr4.ep21.ir.stmt.FuncEntryLabel;
+import org.teachfx.antlr4.ep21.ir.stmt.JMP;
+import org.teachfx.antlr4.ep21.ir.stmt.Label;
+import org.teachfx.antlr4.ep21.symtab.type.OperatorType;
+import org.teachfx.antlr4.ep21.utils.Kind;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BasicBlockTest {
+
+    @Test
+    void testBuildFromLinearBlockWhenNoInstructionsThenEmptyBlock() {
+        // Arrange
+        LinearIRBlock block = new LinearIRBlock();
+        List<BasicBlock<IRNode>> cachedNodes = new ArrayList<>();
+
+        // Act
+        BasicBlock<IRNode> basicBlock = BasicBlock.buildFromLinearBlock(block, cachedNodes);
+
+        // Assert
+        assertTrue(basicBlock.isEmpty(), "BasicBlock should be empty when created from an empty LinearIRBlock");
+    }
+
+    @Test
+    void testBuildFromLinearBlockWhenOneInstructionThenOneInstructionBlock() {
+        // Arrange
+        LinearIRBlock block = new LinearIRBlock();
+        block.addStmt(new Label("L1", null));
+        List<BasicBlock<IRNode>> cachedNodes = new ArrayList<>();
+
+        // Act
+        BasicBlock<IRNode> basicBlock = BasicBlock.buildFromLinearBlock(block, cachedNodes);
+
+        // Assert
+        assertEquals(1, basicBlock.codes.size(), "BasicBlock should have one instruction when created from a LinearIRBlock with one instruction");
+    }
+
+    @Test
+    void testBuildFromLinearBlockWhenMultipleInstructionsThenSameNumberOfInstructionsBlock() {
+        // Arrange
+        LinearIRBlock block = new LinearIRBlock();
+        LinearIRBlock thenBlock = new LinearIRBlock();
+        block.addStmt(new Label("L1", null));
+        block.addStmt(new JMP(thenBlock));
+        List<BasicBlock<IRNode>> cachedNodes = new ArrayList<>();
+
+        // Act
+        BasicBlock<IRNode> basicBlock = BasicBlock.buildFromLinearBlock(block, cachedNodes);
+
+        // Assert
+        assertEquals(2, basicBlock.codes.size(), "BasicBlock should have the same number of instructions as the LinearIRBlock");
+    }
+
+    @Test
+    void testBuildFromLinearBlockWhenJumpInstructionThenJumpInstructionBlock() {
+        // Arrange
+        LinearIRBlock block = new LinearIRBlock();
+        LinearIRBlock thenBlock = new LinearIRBlock();
+
+        JMP jumpInstruction = new JMP(thenBlock);
+        block.addStmt(jumpInstruction);
+        List<BasicBlock<IRNode>> cachedNodes = new ArrayList<>();
+
+        // Act
+        BasicBlock<IRNode> basicBlock = BasicBlock.buildFromLinearBlock(block, cachedNodes);
+
+        // Assert
+        assertTrue(basicBlock.getLastInstr() instanceof JMP, "BasicBlock should have a jump instruction when created from a LinearIRBlock with a jump instruction");
+    }
+
+    @Test
+    void testBuildFromLinearBlockWhenConditionalJumpInstructionThenConditionalJumpInstructionBlock() {
+        // Arrange
+        LinearIRBlock block = new LinearIRBlock();
+        LinearIRBlock then = new LinearIRBlock();
+        LinearIRBlock other = new LinearIRBlock();
+
+        var condSlot = new FrameSlot(0);
+
+        CJMP cjumpInstruction = new CJMP(condSlot, then, other);
+        block.addStmt(cjumpInstruction);
+        List<BasicBlock<IRNode>> cachedNodes = new ArrayList<>();
+
+        // Act
+        BasicBlock<IRNode> basicBlock = BasicBlock.buildFromLinearBlock(block, cachedNodes);
+
+        // Assert
+        assertTrue(basicBlock.getLastInstr() instanceof CJMP, "BasicBlock should have a conditional jump instruction when created from a LinearIRBlock with a conditional jump instruction");
+    }
+
+    @Test
+    void testBuildFromLinearBlockWhenFunctionEntryLabelThenFunctionEntryLabelBlock() {
+        // Arrange
+        LinearIRBlock block = new LinearIRBlock();
+        FuncEntryLabel funcEntryLabel = new FuncEntryLabel("main", 0, 0, null);
+        block.addStmt(funcEntryLabel);
+        List<BasicBlock<IRNode>> cachedNodes = new ArrayList<>();
+
+        // Act
+        BasicBlock<IRNode> basicBlock = BasicBlock.buildFromLinearBlock(block, cachedNodes);
+
+        // Assert
+        assertTrue(basicBlock.getLastInstr() instanceof FuncEntryLabel, "BasicBlock should have a function entry label when created from a LinearIRBlock with a function entry label");
+    }
+
+    @Test
+    void testBuildFromLinearBlockWhenLabelThenLabelBlock() {
+        // Arrange
+        LinearIRBlock block = new LinearIRBlock();
+        Label label = new Label("L1", null);
+        block.addStmt(label);
+        List<BasicBlock<IRNode>> cachedNodes = new ArrayList<>();
+
+        // Act
+        BasicBlock<IRNode> basicBlock = BasicBlock.buildFromLinearBlock(block, cachedNodes);
+
+        // Assert
+        assertTrue(basicBlock.getLastInstr() instanceof Label, "BasicBlock should have a label when created from a LinearIRBlock with a label");
+    }
+
+    // Additional tests for other methods can be added here following the same pattern.
+}
diff --git a/ep21/src/test/java/org/teachfx/antlr4/ep21/pass/codegen/CymbolAssemblerTest.java b/ep21/src/test/java/org/teachfx/antlr4/ep21/pass/codegen/CymbolAssemblerTest.java
new file mode 100644
index 0000000..cc70f08
--- /dev/null
+++ b/ep21/src/test/java/org/teachfx/antlr4/ep21/pass/codegen/CymbolAssemblerTest.java
@@ -0,0 +1,46 @@
+package org.teachfx.antlr4.ep21.pass.codegen;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class CymbolAssemblerTest {
+    private CymbolAssembler cymbolAssembler;
+
+    @BeforeEach
+    public void setUp() {
+        cymbolAssembler = new CymbolAssembler();
+    }
+
+    @Test
+    public void testEmitWhenCalledThenAssembleCmdBufferContainsCommand() {
+        // Arrange
+        String command = "iconst 5";
+
+        // Act
+        cymbolAssembler.emit(command);
+
+        // Assert
+        assertEquals( command + "\n", cymbolAssembler.getAsmInfo());
+    }
+
+    @Test
+    public void testEmitWhenCalledMultipleTimesThenAssembleCmdBufferContainsCommands() {
+        // Arrange
+        String command1 = "iconst 5";
+        String command2 = "istore 1";
+
+        // Act
+        cymbolAssembler.emit(command1);
+        cymbolAssembler.emit(command2);
+
+        // Assert
+        assertEquals(command1 + "\n" + command2 + "\n", cymbolAssembler.getAsmInfo());
+    }
+
+    // Add more tests for other methods in the CymbolAssembler class
+    // For example, you can test the 'visit' methods with different types of IR nodes
+    // You can create mock IR nodes and pass them to the 'visit' methods
+    // Then, you can check if the 'assembleCmdBuffer' list contains the correct assembly commands
+}
diff --git a/scripts/check_utf8.py b/scripts/check_utf8.py
new file mode 100644
index 0000000..898c8ad
--- /dev/null
+++ b/scripts/check_utf8.py
@@ -0,0 +1,32 @@
+import os
+
+def is_utf8(file_path):
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            f.read()
+        return True
+    except UnicodeDecodeError:
+        return False
+    except Exception as e:
+        print(f"Error reading file: {file_path}")
+        print(e)
+        return False
+
+def find_non_utf8_files(directory):
+    non_utf8_files = []
+    for root, dirs, files in os.walk(directory):
+        for file in files:
+            file_path = os.path.join(root, file)
+            if not is_utf8(file_path):
+                non_utf8_files.append(file_path)
+    return non_utf8_files
+
+ep20_directory = "../ep20"
+non_utf8_files = find_non_utf8_files(ep20_directory)
+
+if len(non_utf8_files) > 0:
+    print("以下文件不符合UTF-8规范：")
+    for file in non_utf8_files:
+        print(file)
+else:
+    print("所有文件都符合UTF-8规范。")
\ No newline at end of file
diff --git a/scripts/cp_prototype.py b/scripts/cp_prototype.py
new file mode 100644
index 0000000..0ec9e45
--- /dev/null
+++ b/scripts/cp_prototype.py
@@ -0,0 +1,27 @@
+import os
+import shutil
+import fileinput
+
+# 源目录
+src_dir = "../ep20/src"
+# 目标目录
+dest_dir = "../ep21/src"
+
+# 拷贝源目录到目标目录，并将目录名从ep20改为ep21
+shutil.copytree(src_dir, dest_dir, ignore=shutil.ignore_patterns("*.DS_Store", "*.class"))
+
+# 遍历目标目录，将子目录中包含ep20的目录名改为ep21
+for root, dirs, files in os.walk(dest_dir):
+    for dir in dirs:
+        if "ep20" in dir:
+            old_dir_path = os.path.join(root, dir)
+            new_dir_path = os.path.join(root, dir.replace("ep20", "ep21"))
+            os.rename(old_dir_path, new_dir_path)
+
+# 替换文件中的字符串
+for root, dirs, files in os.walk(dest_dir):
+    for file in files:
+        file_path = os.path.join(root, file)
+        with fileinput.FileInput(file_path, inplace=True) as f:
+            for line in f:
+                print(line.replace("org.teachfx.antlr4.ep20", "org.teachfx.antlr4.ep21"), end='')
\ No newline at end of file