diff --git a/AssemblyGenerator.cpp b/AssemblyGenerator.cpp
new file mode 100644
index 0000000..e554cc5
--- /dev/null
+++ b/AssemblyGenerator.cpp
@@ -0,0 +1,204 @@
+// AssemblyGenerator.cpp
+#include "AssemblyGenerator.h"
+#include <sstream>
+#include <iostream>
+#include <cctype>
+#include <cassert>
+
+AssemblyGenerator::AssemblyGenerator(const std::vector<Quad> &quads)
+        : quads_(quads), stackSize_(0) {
+    allocateStack();
+}
+
+void AssemblyGenerator::allocateStack() {
+    int offset = 0;
+
+    // 1) 给所有源变量（localOffset_）分配空间
+    for (auto &q : quads_) {
+        if (!q.var.empty() && localOffset_.count(q.var) == 0) {
+            offset += 8;
+            localOffset_[q.var] = offset;
+        }
+    }
+
+    // 2) 给所有临时变量（t1, t2, ...）分配空间
+    for (auto &q : quads_) {
+        if (!q.result.empty() && q.result[0] == 't'
+            && tempOffset_.count(q.result) == 0) {
+            offset += 8;
+            tempOffset_[q.result] = offset;
+        }
+    }
+
+    // 16 字节对齐
+    stackSize_ = ((offset + 15) / 16) * 16;
+}
+
+std::string AssemblyGenerator::generate() {
+    std::ostringstream out;
+
+    // 1) 段和全局符号声明
+    out << ".text\n";
+    out << ".globl _main\n";
+
+    // 2) 如果首条 IR 是一条 "label main"，先输出 _main:，然后 prologue
+    size_t idx = 0;
+    if (!quads_.empty() && quads_[0].op == "label" && quads_[0].result == "main") {
+        out << "_main:\n";
+        emitPrologue(out);
+        idx = 1;
+    } else {
+        // 否则也输出 prologue
+        emitPrologue(out);
+    }
+
+    // 3) 其余指令
+    for (size_t i = idx; i < quads_.size(); ++i) {
+        emitInstruction(quads_[i], out);
+    }
+
+    // 4) epilogue
+    emitEpilogue(out);
+    return out.str();
+}
+
+void AssemblyGenerator::emitPrologue(std::ostream &os) const {
+    os << "\tstp x29, x30, [sp, #-16]!   // push FP, LR\n";
+    os << "\tmov x29, sp\n";
+    if (stackSize_ > 0) {
+        os << "\tsub sp, sp, #" << stackSize_ << "\n";
+    }
+}
+
+void AssemblyGenerator::emitEpilogue(std::ostream &os) const {
+    if (stackSize_ > 0) {
+        os << "\tadd sp, sp, #" << stackSize_ << "\n";
+    }
+    os << "\tldp x29, x30, [sp], #16   // pop FP, LR\n";
+    os << "\tret\n";
+}
+
+void AssemblyGenerator::loadOperand(const std::string &name, std::ostream &os) const {
+    if (!name.empty() && std::isdigit(name[0])) {
+        // 立即数
+        os << "\tmov w9, #" << name << "\n";
+    }
+    else if (localOffset_.count(name)) {
+        // 局部变量
+        os << "\tldr w9, [x29, #-" << localOffset_.at(name) << "]\n";
+    }
+    else if (tempOffset_.count(name)) {
+        // 临时变量
+        os << "\tldr w9, [x29, #-" << tempOffset_.at(name) << "]\n";
+    }
+    else {
+        // 全局变量
+        os << "\tadrp x10, " << name << "\n";
+        os << "\tadd  x10, x10, :lo12:" << name << "\n";
+        os << "\tldr w9, [x10]\n";
+    }
+}
+
+void AssemblyGenerator::storeResult(const std::string &name, std::ostream &os) const {
+    if (localOffset_.count(name)) {
+        // 局部变量
+        os << "\tstr w9, [x29, #-" << localOffset_.at(name) << "]\n";
+    }
+    else if (tempOffset_.count(name)) {
+        // 临时变量
+        os << "\tstr w9, [x29, #-" << tempOffset_.at(name) << "]\n";
+    }
+    else {
+        // 全局变量
+        os << "\tadrp x10, " << name << "\n";
+        os << "\tadd  x10, x10, :lo12:" << name << "\n";
+        os << "\tstr w9, [x10]\n";
+    }
+}
+
+void AssemblyGenerator::emitInstruction(const Quad &q, std::ostream &os) const {
+    using std::string;
+
+    // 标签
+    if (q.op == "label") {
+        // 非 main 的其他标签直接原样输出
+        if (q.result != "main") {
+            os << q.result << ":\n";
+        }
+        return;
+    }
+
+    // 无条件跳转
+    if (q.op == "goto") {
+        os << "\tb " << q.result << "\n";
+        return;
+    }
+
+    // ifFalse x -> cmp x, #0; beq L
+    if (q.op == "ifFalse") {
+        loadOperand(q.arg1, os);
+        os << "\tcmp w9, #0\n";
+        os << "\tbeq " << q.result << "\n";
+        return;
+    }
+
+    // 赋值 =
+    if (q.op == "=") {
+        loadOperand(q.arg1, os);
+        storeResult(q.result, os);
+        return;
+    }
+
+    // 二元算术/逻辑运算
+    static const std::unordered_map<string, string> binOpMap = {
+            { "+",  "add"  }, { "-",  "sub"  }, { "*",   "mul"  },
+            { "/",  "sdiv" }, { "<<", "lsl"  }, { ">>",  "lsr"  },
+            { "&",  "and"  }, { "|",  "orr"  }, { "^",   "eor"  }
+    };
+    if (binOpMap.count(q.op)) {
+        loadOperand(q.arg1, os);
+        os << "\tmov w10, w9\n";
+        loadOperand(q.arg2, os);
+        os << "\tmov w11, w9\n";
+        os << "\t" << binOpMap.at(q.op) << " w9, w10, w11\n";
+        storeResult(q.result, os);
+        return;
+    }
+
+    // 比较运算，使用 cset 生成布尔 0/1
+    static const std::unordered_map<string, string> cmpCondMap = {
+            {"==", "eq"}, {"!=", "ne"},
+            {"<",  "lt"}, {">",  "gt"},
+            {"<=", "le"}, {">=", "ge"}
+    };
+    if (cmpCondMap.count(q.op)) {
+        loadOperand(q.arg1, os);
+        os << "\tmov w10, w9\n";
+        loadOperand(q.arg2, os);
+        os << "\tmov w11, w9\n";
+        os << "\tcmp w10, w11\n";
+        os << "\tcset w9, " << cmpCondMap.at(q.op) << "\n";
+        storeResult(q.result, os);
+        return;
+    }
+
+    // call / param / return
+    if (q.op == "param") {
+        return;
+    }
+    if (q.op == "call") {
+        os << "\tbl " << q.arg1 << "\n";
+        os << "\tmov w9, w0\n";
+        storeResult(q.result, os);
+        return;
+    }
+    if (q.op == "return") {
+        if (!q.arg1.empty()) {
+            loadOperand(q.arg1, os);
+            os << "\tmov w0, w9\n";
+        }
+        return;
+    }
+
+    std::cerr << "Unhandled IR op: " << q.op << "\n";
+}
diff --git a/AssemblyGenerator.h b/AssemblyGenerator.h
new file mode 100644
index 0000000..e0efae9
--- /dev/null
+++ b/AssemblyGenerator.h
@@ -0,0 +1,28 @@
+// AssemblyGenerator.h
+#ifndef MINI_C_ASSEMBLY_GENERATOR_H
+#define MINI_C_ASSEMBLY_GENERATOR_H
+
+#include "ir.h"
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <ostream>
+
+class AssemblyGenerator {
+public:
+    explicit AssemblyGenerator(const std::vector<Quad> &quads);
+    std::string generate();
+private:
+    const std::vector<Quad> &quads_;
+    std::unordered_map<std::string, int> localOffset_;
+    std::unordered_map<std::string, int> tempOffset_;
+    int stackSize_;
+    void allocateStack();
+    void emitPrologue(std::ostream &os) const;
+    void emitEpilogue(std::ostream &os) const;
+    void emitInstruction(const Quad &q, std::ostream &os) const;
+    void loadOperand(const std::string &name, std::ostream &os) const;
+    void storeResult(const std::string &name, std::ostream &os) const;
+};
+
+#endif // MINI_C_ASSEMBLY_GENERATOR_H
diff --git a/InstructionEncoder.cpp b/InstructionEncoder.cpp
new file mode 100644
index 0000000..7ed7af4
--- /dev/null
+++ b/InstructionEncoder.cpp
@@ -0,0 +1,169 @@
+// InstructionEncoder.cpp
+#include "InstructionEncoder.h"
+#include <cstdint>
+
+// —————————————————————————————————————————————
+// 1) 控制流
+// 无条件跳转 B <label>
+uint32_t encodeB(int32_t offset) {
+    // offset 必须是 4 字节对齐，且能 fit 26b*2
+    uint32_t imm26 = (uint32_t)(offset >> 2) & 0x03ffffffu;
+    // opcode: 0b000101 imm26
+    return (0b000101u << 26) | imm26;
+}
+
+// 返回 RET
+uint32_t encodeRET() {
+    return 0xd65f03c0u;
+}
+
+// 空指令 NOP
+uint32_t encodeNOP() {
+    return 0xd503201fu;
+}
+
+// —————————————————————————————————————————————
+// 2) 〈Data Processing – Immediate〉
+uint32_t encodeADDimm(uint8_t rd, uint8_t rn, uint16_t imm) {
+    // 32-bit ADD immediate: sf=0, opc=00, S=0, opcode(24‐21)=1001
+    // base = 0x11000000
+    uint32_t imm12 = imm & 0xfffu;            // 12-bit
+    return 0x11000000u
+           | (imm12 << 10)
+           | (uint32_t(rn) << 5)
+           | uint32_t(rd);
+}
+
+uint32_t encodeSUBimm(uint8_t rd, uint8_t rn, uint16_t imm) {
+    // 32-bit SUB immediate: sf=0, opc=01, S=0, opcode=1001
+    // base = 0x51000000
+    uint32_t imm12 = imm & 0xfffu;
+    return 0x51000000u
+           | (imm12 << 10)
+           | (uint32_t(rn) << 5)
+           | uint32_t(rd);
+}
+
+// MOVZ (move wide immediate)
+//   movz rd, #imm16, LSL #(highHalf?16:0)
+uint32_t encodeMOVz(uint8_t rd, uint16_t imm16, bool highHalf) {
+    // sf=0, opc=2 (MOVZ), opcode=100101, base=0x52800000
+    uint32_t hw = highHalf ? 1u : 0u;
+    return 0x52800000u
+           | (hw << 21)                     // LSL 高半字
+           | (uint32_t(imm16 & 0xffffu) << 5)
+           | uint32_t(rd);
+}
+
+// CMP immediate （等价于 SUBS WZR, rn, #imm）
+uint32_t encodeCMPimm(uint8_t rn, uint16_t imm) {
+    // 32-bit SUBS immediate: sf=0, opc=01 (SUB), S=1, opcode=1001 ➔ base=0x71000000
+    uint32_t imm12 = imm & 0xfffu;
+    return 0x71000000u
+           | (imm12 << 10)
+           | (uint32_t(rn) << 5)
+           | 31u;    // WZR 编号 31
+}
+
+// CSET rd, cond （alias for CSEL rd, WZR, WZR, cond）
+uint32_t encodeCSET(uint8_t rd, uint8_t cond) {
+    // 32-bit CSEL: sf=0, opcode=1010_100, base=0x1A200000
+    // Rn=WZR(31), Rm=WZR(31), cond 放在 bits[15:12]
+    return 0x1A200000u
+           | (31u   << 5)    // Rn = WZR
+           | (31u   << 16)   // Rm = WZR
+           | (uint32_t(cond & 0xFu) << 12)
+           | uint32_t(rd);
+}
+
+// —————————————————————————————————————————————
+// 3) 〈Load/Store Unsigned Immediate〉
+//
+// STR Wt, [Xn, #imm]   (32-bit 存 4-byte，imm 必须 4 字节对齐)
+// LDR Wt, [Xn, #imm]   (32-bit 载 4-byte，imm 必须 4 字节对齐)
+// 立即数在编码中以 imm12<<2 形式出现
+
+uint32_t encodeSTR(uint8_t rt, uint8_t rn, int16_t offset) {
+    // base for STR (unsigned imm, 32-bit) = 0x39000000
+    uint32_t imm12 = (uint32_t(offset) >> 2) & 0xfffu;
+    return 0x39000000u
+           | (imm12 << 10)
+           | (uint32_t(rn) << 5)
+           | uint32_t(rt);
+}
+
+uint32_t encodeLDR(uint8_t rt, uint8_t rn, int16_t offset) {
+    // base for LDR (unsigned imm, 32-bit) = 0x39400000
+    uint32_t imm12 = (uint32_t(offset) >> 2) & 0xfffu;
+    return 0x39400000u
+           | (imm12 << 10)
+           | (uint32_t(rn) << 5)
+           | uint32_t(rt);
+}
+
+// —————————————————————————————————————————————
+// 4) 〈Load/Store Pair, Immediate〉 （64-bit 版，用来存/取一对寄存器）
+//
+// STP rt1, rt2, [rn, #imm]!
+// LDP rt1, rt2, [rn], #imm
+//
+// imm 必须 8 字节对齐，编码里以 imm7<<3 的形式出现
+
+uint32_t encodeSTP(uint8_t rt1, uint8_t rt2, uint8_t rn, int16_t offset) {
+    // 存 64-bit 对，base unsigned imm = 0xA9000000
+    // pre-index: P=1,U=0,W=1 ➜ P(bit24)=1, U(bit23)=0, W(bit21)=1
+    uint32_t imm7 = (uint32_t(offset) >> 3) & 0x7fu;
+    return 0xA9000000u
+           | (imm7 << 15)
+           | (1u << 24)    // P
+           | (0u << 23)    // U
+           | (1u << 21)    // W
+           | (uint32_t(rn) << 5)
+           | (uint32_t(rt2) << 10)
+           | uint32_t(rt1);
+}
+
+uint32_t encodeLDP(uint8_t rt1, uint8_t rt2, uint8_t rn, int16_t offset) {
+    // 取 64-bit 对，base unsigned imm = 0xA9400000
+    // post-index: P=0,U=1,W=1 ➜ P=0, U=1, W=1
+    uint32_t imm7 = (uint32_t(offset) >> 3) & 0x7fu;
+    return 0xA9400000u
+           | (imm7 << 15)
+           | (0u << 24)    // P
+           | (1u << 23)    // U
+           | (1u << 21)    // W
+           | (uint32_t(rn) << 5)
+           | (uint32_t(rt2) << 10)
+           | uint32_t(rt1);
+}
+
+// 5) Data-processing (register): ADD rd, rn, rm
+uint32_t encodeADDreg(uint8_t rd, uint8_t rn, uint8_t rm) {
+    return 0x0B000000u
+           | (uint32_t(rm) << 16)
+           | (uint32_t(rn) << 5)
+           |  uint32_t(rd);
+}
+
+// 6) Compare register: CMP rn, rm  (＝ SUBS WZR, rn, rm)
+uint32_t encodeCMPreg(uint8_t rn, uint8_t rm) {
+    // 32-bit SUBS (shifted register, no shift) with WZR destination:
+    //   sf=0, opc=1, S=1, opcode=10001011000 → base = 0x2B000000 | S-bit
+    // Actually: SUBS register base = 0x6B000000
+    //   bits[20:16] = Rm, [9:5] = Rn, [4:0] = 31 (WZR)
+    return 0x6B000000u
+           | (uint32_t(rm) << 16)
+           | (uint32_t(rn) << 5)
+           |  31u;
+}
+
+// 7) Conditional branch: B.<cond> offset
+uint32_t encodeBCond(uint8_t cond, int32_t offset) {
+    // imm19 = (offset >> 2) & 0x7FFFF
+    // opcode = 0b01010100 (0x54) at bits[31:24]
+    // 32-bit instruction = 0b01010100|imm19|cond
+    uint32_t imm19 = (uint32_t(offset) >> 2) & 0x7FFFFu;
+    return (0x54u << 24)
+           | (imm19 << 5)
+           | (cond & 0xFu);
+}
\ No newline at end of file
diff --git a/InstructionEncoder.h b/InstructionEncoder.h
new file mode 100644
index 0000000..6add86e
--- /dev/null
+++ b/InstructionEncoder.h
@@ -0,0 +1,61 @@
+// InstructionEncoder.h
+#ifndef INSTRUCTION_ENCODER_H
+#define INSTRUCTION_ENCODER_H
+
+#include <cstdint>
+
+// 无条件跳转 B <label>
+uint32_t encodeB(int32_t offset);
+
+// 返回 RET
+uint32_t encodeRET();
+
+// 空指令 NOP
+uint32_t encodeNOP();
+
+// ADD (immediate): add rd, rn, #imm
+uint32_t encodeADDimm(uint8_t rd, uint8_t rn, uint16_t imm);
+
+// SUB (immediate): sub rd, rn, #imm
+uint32_t encodeSUBimm(uint8_t rd, uint8_t rn, uint16_t imm);
+
+// MOVZ (move wide immediate): movz rd, #imm16, {LSL #16 if highHalf}
+uint32_t encodeMOVz(uint8_t rd, uint16_t imm16, bool highHalf);
+
+// CMP immediate: cmp rn, #imm  (encoded as subs wzr, rn, #imm)
+uint32_t encodeCMPimm(uint8_t rn, uint16_t imm);
+
+// CSET (condition set): cset rd, <cond>
+//   cond: 0=eq,1=ne,2=hs,3=lo,4=mi,5=pl,6=vs,7=vc,8=hi,9=ls,10=ge,11=lt,12=gt,13=le,14=al,15=nv
+uint32_t encodeCSET(uint8_t rd, uint8_t cond);
+
+// STP (pre-index): stp rt1, rt2, [rn, #offset]!
+uint32_t encodeSTP(uint8_t rt1, uint8_t rt2, uint8_t rn, int16_t offset);
+
+// LDP (post-index): ldp rt1, rt2, [rn], #offset
+uint32_t encodeLDP(uint8_t rt1, uint8_t rt2, uint8_t rn, int16_t offset);
+
+// STR (unsigned immediate): str rt, [rn, #offset]
+uint32_t encodeSTR(uint8_t rt, uint8_t rn, int16_t offset);
+
+// LDR (unsigned immediate): ldr rt, [rn, #offset]
+uint32_t encodeLDR(uint8_t rt, uint8_t rn, int16_t offset);
+
+// ADD sp, sp, #imm
+inline uint32_t encodeADDsp(uint16_t imm) {
+    return encodeADDimm(/*rd=*/31, /*rn=*/31, imm);
+}
+
+// SUB sp, sp, #imm
+inline uint32_t encodeSUBsp(uint16_t imm) {
+    return encodeSUBimm(/*rd=*/31, /*rn=*/31, imm);
+}
+
+
+// ADD (register): add rd, rn, rm
+uint32_t encodeADDreg(uint8_t rd, uint8_t rn, uint8_t rm);
+// Compare (register): subs wzr, rn, rm
+uint32_t encodeCMPreg(uint8_t rn, uint8_t rm);
+// Conditional branch B.<cond> imm
+uint32_t encodeBCond(uint8_t cond, int32_t offset);
+#endif // INSTRUCTION_ENCODER_H
diff --git a/ObjectFileGenerator.cpp b/ObjectFileGenerator.cpp
new file mode 100644
index 0000000..3f4c701
--- /dev/null
+++ b/ObjectFileGenerator.cpp
@@ -0,0 +1,113 @@
+// ObjectFileGenerator.cpp
+#include "ObjectFileGenerator.h"
+#include <fstream>
+#include <cstring>
+#include <mach-o/loader.h>
+#include <mach-o/nlist.h>
+#include <mach/vm_prot.h>
+#include <iostream>
+
+bool ObjectFileGenerator::writeObject(const std::string &filename,
+                                      const std::vector<uint32_t> &code) {
+
+    std::cout << "Code size: " << code.size() << std::endl;
+    for (auto instr : code) {
+        std::cout << std::hex << instr << std::endl;  // 打印机器码
+    }
+    // 1) 计算各部分大小/偏移
+    const uint32_t segcmd_sz    = sizeof(segment_command_64) + sizeof(section_64);
+    const uint32_t symcmd_sz    = sizeof(symtab_command);
+    const uint32_t ncmds        = 2;  // __TEXT + SYMTAB
+    const uint32_t sizeofcmds   = segcmd_sz + symcmd_sz;
+    const uint32_t fileoff_code = sizeof(mach_header_64) + sizeofcmds;
+    const uint32_t codesize     = uint32_t(code.size() * 4);
+
+    // 字符串表： "\0_main\0"
+    std::vector<char> strtab = {'\0','_','m','a','i','n','\0'};
+    const uint32_t nsyms   = 1;
+    const uint32_t symoff  = fileoff_code + codesize;
+
+    std::cout << "Symbol offset: " << symoff << std::endl;
+
+    const uint32_t stroff  = symoff + nsyms * sizeof(nlist_64);
+    const uint32_t strsize = uint32_t(strtab.size());
+
+    // 2) Mach-O Header
+    mach_header_64 mh{};
+    mh.magic      = MH_MAGIC_64;
+    mh.cputype    = CPU_TYPE_ARM64;
+    mh.cpusubtype = CPU_SUBTYPE_ARM64_ALL;
+    mh.filetype   = MH_OBJECT;
+    mh.ncmds      = ncmds;
+    mh.sizeofcmds = sizeofcmds;
+    mh.flags      = 0;
+    mh.reserved   = 0;
+
+    // 3) LC_SEGMENT_64 for __TEXT/__text
+    segment_command_64 sc{};
+    sc.cmd      = LC_SEGMENT_64;
+    sc.cmdsize  = segcmd_sz;
+    std::strncpy(sc.segname, "__TEXT", sizeof(sc.segname));
+    sc.vmaddr   = 0;
+    sc.vmsize   = codesize;
+    sc.fileoff  = fileoff_code;
+    sc.filesize = codesize;
+    sc.maxprot  = VM_PROT_READ | VM_PROT_WRITE;
+    sc.initprot = VM_PROT_READ | VM_PROT_WRITE;
+    sc.nsects   = 1;
+    sc.flags    = 0;
+
+    section_64 sect{};
+    std::strncpy(sect.sectname, "__text", sizeof(sect.sectname));
+    std::strncpy(sect.segname,  "__TEXT", sizeof(sect.segname));
+    sect.addr    = 0;
+    sect.size    = codesize;
+    sect.offset  = fileoff_code;
+    sect.align   = 2;  // 4-byte align
+    sect.reloff  = 0;
+    sect.nreloc  = 0;
+    sect.flags   = 0;
+    sect.reserved1 = sect.reserved2 = sect.reserved3 = 0;
+
+    // 4) LC_SYMTAB
+    symtab_command stc{};
+    stc.cmd      = LC_SYMTAB;
+    stc.cmdsize  = symcmd_sz;
+    stc.symoff   = symoff;
+    stc.nsyms    = nsyms;
+    stc.stroff   = stroff;
+    stc.strsize  = strsize;
+
+    // 5) 写入 header + load commands + section
+    std::ofstream ofs(filename, std::ios::binary);
+    if (!ofs) return false;
+    ofs.write(reinterpret_cast<char*>(&mh),  sizeof(mh));
+    ofs.write(reinterpret_cast<char*>(&sc),  sizeof(segment_command_64));
+    ofs.write(reinterpret_cast<char*>(&sect), sizeof(section_64));
+    ofs.write(reinterpret_cast<char*>(&stc), sizeof(stc));
+
+    // 6) 写入机器码
+    ofs.seekp(fileoff_code, std::ios::beg);
+    for (auto instr : code) {
+        ofs.put(char(instr & 0xFF));
+        ofs.put(char((instr >> 8) & 0xFF));
+        ofs.put(char((instr >> 16) & 0xFF));
+        ofs.put(char((instr >> 24) & 0xFF));
+    }
+
+    // 7) 写入符号表 (_main)
+    ofs.seekp(symoff, std::ios::beg);
+    nlist_64 nl{};
+    nl.n_un.n_strx = 1;               // "_main" 在 strtab 的偏移
+    nl.n_type      = N_SECT | N_EXT;  // 定义在 section、对外可见
+    nl.n_sect      = 1;               // 第一节 __text
+    nl.n_desc      = 0;
+    nl.n_value     = 0;               // 从节首开始
+    ofs.write(reinterpret_cast<char*>(&nl), sizeof(nl));
+
+    // 8) 写入字符串表
+    ofs.seekp(stroff, std::ios::beg);
+    ofs.write(strtab.data(), strtab.size());
+
+    return true;
+}
diff --git a/ObjectFileGenerator.h b/ObjectFileGenerator.h
new file mode 100644
index 0000000..4ec4a2e
--- /dev/null
+++ b/ObjectFileGenerator.h
@@ -0,0 +1,18 @@
+#ifndef OBJECT_FILE_GENERATOR_H
+#define OBJECT_FILE_GENERATOR_H
+
+#include <vector>
+#include <cstdint>
+#include <string>
+
+/// 把一段 32-bit ARM64 指令流写成一个 Mach-O 64-bit relocatable object (.o) 文件
+class ObjectFileGenerator {
+public:
+    /// \param filename 输出文件名，比如 "out.o"
+    /// \param code     每个元素是一条 32-bit 小端机器指令
+    /// \return         true 成功，false 失败
+    static bool writeObject(const std::string &filename,
+                            const std::vector<uint32_t> &code);
+};
+
+#endif // OBJECT_FILE_GENERATOR_H
diff --git a/PrettyPrinter.cpp b/PrettyPrinter.cpp
new file mode 100644
index 0000000..62368ca
--- /dev/null
+++ b/PrettyPrinter.cpp
@@ -0,0 +1,411 @@
+// PrettyPrinter.cpp
+#include "PrettyPrinter.h"
+
+void PrettyPrinter::print(ASTNode* root) {
+    printNode(root);
+    out.flush();
+}
+
+void PrettyPrinter::indent(){
+    out << std::string(indentLevel * indentWidth, ' ');
+}
+
+void PrettyPrinter::newline(){
+    out << "\n";
+}
+
+void PrettyPrinter::withIndent(const std::function<void()>& f){
+    indentLevel++;
+    f();
+    indentLevel--;
+}
+
+bool PrettyPrinter::isStmt(ASTTag t){
+    using T = ASTTag;
+    return t==T::IF_STMT || t==T::FOR_STMT || t==T::FOR_DECL_STMT
+           || t==T::WHILE_STMT|| t==T::RETURN_STMT
+           || t==T::EXPR_STMT || t==T::COMPOUND_STMT
+           || t==T::DECL_STMT;
+}
+
+void PrettyPrinter::printNode(ASTNode* n){
+    if (!n) return;
+    switch (n->tag) {
+        case ASTTag::TRANSL_UNIT:        printTranslationUnit(n); break;
+        case ASTTag::FUNCTION_DEF:       printFunctionDef(n);    break;
+        case ASTTag::DECL_STMT:          printDeclStmt(n);       break;
+        case ASTTag::DECLARATION:
+            indent();
+            printDeclaration(n);
+            out << ";";
+            newline();
+            break;
+        case ASTTag::IF_STMT:            printIfStmt(n);         break;
+        case ASTTag::FOR_STMT:
+        case ASTTag::FOR_DECL_STMT:      printForStmt(n);        break;
+        case ASTTag::WHILE_STMT:         printWhileStmt(n);      break;
+        case ASTTag::RETURN_STMT:        printReturnStmt(n);     break;
+        case ASTTag::COMPOUND_STMT:      printCompoundStmt(n);   break;
+        case ASTTag::EXPR_STMT:
+                indent();
+                // EXPR_STMT.kids[0] 可能是 nullptr（空语句）或者表达式
+                if (!n->kids.empty() && n->kids[0]) {
+                printExpr(n->kids[0]);
+            }
+            out << ";";
+                newline();
+                    break;
+
+                        default:
+                    if (isStmt(n->tag)) {
+                    // 其它语句回退到 “表达式语句” 的处理
+                            indent();
+                    printExpr(n);
+                    out << ";";
+                    newline();
+                } else {
+                    printExpr(n);
+                }
+
+    }
+}
+
+// ── 顶层翻译单元 ──
+void PrettyPrinter::printTranslationUnit(ASTNode* n){
+    for (auto child : n->kids){
+        printNode(child);
+        newline();
+    }
+}
+
+// ── 函数定义 ──
+// kids: [spec_list, declarator, (opt decl_list), compound_stmt]
+void PrettyPrinter::printFunctionDef(ASTNode* n){
+    indent();
+    printDeclSpec(n->kids[0]);
+    out<<" ";
+    printDeclarator(n->kids[1]);          // 包含函数名和参数
+    out<<" ";
+    printCompoundStmt(n->kids.back());
+    newline();
+}
+
+// ── 声明语句、声明 ──
+void PrettyPrinter::printDeclStmt(ASTNode* n){
+    indent();
+    printDeclaration(n->kids[0]);
+    out<<";";
+    newline();
+}
+
+void PrettyPrinter::printDeclaration(ASTNode* n) {
+    // kids: [spec_list, init_decl_list]
+    printDeclSpec(n->kids[0]);
+     // 如果有初始化列表，就输出空格并专门打印它
+        if (n->kids.size() > 1 && n->kids[1]) {
+            out << " ";
+            printInitDeclList(n->kids[1]);
+        }
+}
+
+// ── If ──
+void PrettyPrinter::printIfStmt(ASTNode* n){
+    indent(); out<<"if ("; printExpr(n->kids[0]); out<<") ";
+    if (n->kids[1]->tag==ASTTag::COMPOUND_STMT){
+        printCompoundStmt(n->kids[1]);
+    } else {
+        newline();
+        withIndent([&](){ printNode(n->kids[1]); });
+    }
+    if (n->kids.size()==3){
+        indent(); out<<"else ";
+        if (n->kids[2]->tag==ASTTag::COMPOUND_STMT)
+            printCompoundStmt(n->kids[2]);
+        else {
+            newline();
+            withIndent([&](){ printNode(n->kids[2]); });
+        }
+    }
+}
+
+// ── For ──
+// kids: [init, cond, iter?, body]
+void PrettyPrinter::printForStmt(ASTNode* n){
+    indent(); out<<"for (";
+    if (n->kids[0]) {
+        if (n->kids[0]->tag == ASTTag::DECLARATION) {
+            printDeclaration(n->kids[0]);
+        } else {
+            ASTNode* initNode = n->kids[0];
+            if (initNode->tag == ASTTag::EXPR_STMT
+                && !initNode->kids.empty()
+                && initNode->kids[0])
+                initNode = initNode->kids[0];
+            printExpr(initNode);
+        }
+    }
+
+    out<<"; ";
+    // cond: 通常是 EXPR_STMT 包装
+    if (n->kids[1]) {
+        ASTNode* condNode = n->kids[1];
+        if (condNode->tag == ASTTag::EXPR_STMT
+            && !condNode->kids.empty()
+            && condNode->kids[0])
+            condNode = condNode->kids[0];
+        printExpr(condNode);
+    }
+
+    out<<"; ";
+//    ASTNode* iter = (n->kids.size()>2 ? n->kids[2] : nullptr);
+//    if (iter) printExpr(iter);
+
+    // iter: 有时也是 EXPR_STMT，有时直接是表达式
+    if (n->kids.size() > 2 && n->kids[2]) {
+        ASTNode* iterNode = n->kids[2];
+        if (iterNode->tag == ASTTag::EXPR_STMT
+            && !iterNode->kids.empty()
+            && iterNode->kids[0])
+            iterNode = iterNode->kids[0];
+        printExpr(iterNode);
+    }
+
+
+    out<<") ";
+    if (n->kids.back()->tag==ASTTag::COMPOUND_STMT)
+        printCompoundStmt(n->kids.back());
+    else {
+        newline();
+        withIndent([&](){ printNode(n->kids.back()); });
+    }
+}
+
+// ── While ──
+void PrettyPrinter::printWhileStmt(ASTNode* n){
+    indent(); out<<"while ("; printExpr(n->kids[0]); out<<") ";
+    if (n->kids[1]->tag==ASTTag::COMPOUND_STMT)
+        printCompoundStmt(n->kids[1]);
+    else {
+        newline();
+        withIndent([&](){ printNode(n->kids[1]); });
+    }
+}
+
+// ── Return ──
+void PrettyPrinter::printReturnStmt(ASTNode* n){
+    indent(); out<<"return";
+    if (!n->kids.empty()){
+        out<<" ";
+        printExpr(n->kids[0]);
+    }
+    out<<";"; newline();
+}
+
+// ── Compound ──
+void PrettyPrinter::printCompoundStmt(ASTNode* n) {
+    indent();
+    out << "{";
+    newline();
+
+    withIndent([&]() {
+        // 先检查是否真的是一个 BLOCK_ITEM_LIST
+        if (!n->kids.empty()
+            && n->kids[0]
+            && n->kids[0]->tag == ASTTag::BLOCK_ITEM_LIST) {
+            ASTNode* blockList = n->kids[0];
+            for (ASTNode* item : blockList->kids) {
+                if (!item) continue;
+                switch (item->tag) {
+                    case ASTTag::BLOCK_DECL:
+                        // 声明包装：拆开并打印
+                        indent();
+                        printDeclaration(item->kids[0]);
+                        out << ";";
+                        newline();
+                        break;
+                    case ASTTag::BLOCK_STMT:
+                        // 语句包装：取出里面的真正 stmt
+                        if (!item->kids.empty() && item->kids[0]) {
+                            printNode(item->kids[0]);
+                        }
+                        break;
+                    default:
+                        // 其它直接递归
+                        printNode(item);
+                }
+            }
+        } else {
+            // 回退：如果 kids[0] 不是 BLOCK_ITEM_LIST，就打印所有子节点
+            for (ASTNode* child : n->kids) {
+                if (child) printNode(child);
+            }
+        }
+    });
+
+    indent();
+    out << "}";
+    newline();
+}
+
+
+
+// ── 声明符 & 类型相关 ──
+// spec_list: kids 是一连串枚举值
+void PrettyPrinter::printDeclSpec(ASTNode* n){
+    if (!n) return;
+    bool first = true;
+    for (ASTNode* leaf : n->kids) {
+        // 跳过 nullptr 或者不是 SPECIFIER 的节点
+        if (!leaf || leaf->tag != ASTTag::SPECIFIER)
+            continue;
+
+        if (!first) out << " ";
+        first = false;
+
+        int spec = leaf->ival;
+        switch (spec) {
+            case TS_INT:    out << "int";    break;
+            case TS_CHAR:   out << "char";   break;
+            case TS_VOID:   out << "void";   break;
+                // … 其他类型 …
+            default:        out << "/*spec" << spec << "*/";
+        }
+    }
+}
+
+
+// declarator: 可能包含指针、标识符、参数列表
+void PrettyPrinter::printDeclarator(ASTNode* n){
+    // 简化处理：直接从 text 中读函数名或变量名
+    if (!n->text.empty()){
+        out<<n->text;
+    } else if (!n->kids.empty()){
+        // 对于 FUNC_DECL: kids[0] 是 DECLARATOR（带函数名），kids[1] 是 PARAM_LIST
+        if (n->tag==ASTTag::FUNC_DECL){
+            printDeclarator(n->kids[0]);
+            out<<"(";
+            if (n->kids.size()>1) printParamList(n->kids[1]);
+            out<<")";
+            return;
+        } else {
+            printDeclarator(n->kids[0]);
+        }
+    }
+}
+
+// 参数列表
+void PrettyPrinter::printParamList(ASTNode* n){
+    bool first=true;
+    for (auto pd : n->kids){
+        if (!first) out<<", ";
+        first=false;
+        // pd: PARAM_DECL 节点，kids[0] 是 spec_list，kids[1] 可选 declarator
+        printDeclSpec(pd->kids[0]);
+        if (pd->kids.size()>1){
+            out<<" ";
+            printDeclarator(pd->kids[1]);
+        }
+    }
+}
+
+// ── 表达式打印 ──
+void PrettyPrinter::printExpr(ASTNode* n){
+    using T = ASTTag;
+    switch (n->tag){
+        case T::ID:
+            out<<n->text; break;
+        case T::CONST:
+            out<<n->text; break;
+        case T::BINARY:
+            printExpr(n->kids[0]);
+            out<<" "<< static_cast<char>(n->ival) <<" ";
+            printExpr(n->kids[1]);
+            break;
+        case T::UNARY:{
+            int op = n->ival;
+            const char* s = op=='-'? "-" : op=='+'? "+" : "";
+            printUnary(n, s, true);
+            break;
+        }
+        case T::ASSIGN:
+            printExpr(n->kids[0]);
+            out<<" = ";
+            printExpr(n->kids[1]);
+            break;
+        case T::FUNC_CALL:
+            printFuncCall(n);
+            break;
+        case T::ARRAY_REF:
+            printArrayRef(n);
+            break;
+        case T::STRUCT_REF:
+            printStructRef(n);
+            break;
+
+        case T::INIT_EXPR:
+            // 把初始化表达式里的真实表达式解包再打印
+            if (!n->kids.empty() && n->kids[0])
+                printExpr(n->kids[0]);
+                    break;
+        default:
+            out<<"/*unhandled:"<<(int)n->tag<<"*/";
+    }
+}
+
+void PrettyPrinter::printUnary(ASTNode* n, const char* op, bool prefix){
+    if (prefix) out<<op;
+    printExpr(n->kids[0]);
+    if (!prefix) out<<op;
+}
+
+void PrettyPrinter::printFuncCall(ASTNode* n){
+    printExpr(n->kids[0]);
+    out<<"(";
+    if (n->kids.size()>1) printExpr(n->kids[1]);
+    out<<")";
+}
+
+void PrettyPrinter::printArrayRef(ASTNode* n){
+    printExpr(n->kids[0]);
+    out<<"[";
+    printExpr(n->kids[1]);
+    out<<"]";
+}
+
+void PrettyPrinter::printStructRef(ASTNode* n){
+    printExpr(n->kids[0]);
+    out<<(n->flag? "->" : ".");
+    out<<n->text;
+}
+
+
+void PrettyPrinter::printInitDeclList(ASTNode* n) {
+    if (!n) return;
+    bool first = true;
+    for (ASTNode* initDecl : n->kids) {
+        if (!initDecl) continue;
+        if (!first) out << ", ";
+        first = false;
+        // declarator
+        ASTNode* dtor = initDecl->kids[0];
+        printDeclarator(dtor);
+//        // initializer?
+//        if (initDecl->kids.size() > 1 && initDecl->kids[1]) {
+//            out << " = ";
+//            printExpr(initDecl->kids[1]);
+//        }
+
+                // initializer?
+                        if (initDecl->kids.size() > 1 && initDecl->kids[1]) {
+                        out << " = ";
+                        ASTNode* initNode = initDecl->kids[1];
+                        // 如果是 INIT_EXPR，解包再打印
+                                if (initNode->tag == ASTTag::INIT_EXPR
+                                                                      && !initNode->kids.empty()
+                                                                                          && initNode->kids[0])
+                                initNode = initNode->kids[0];
+                        printExpr(initNode);
+                    }
+
+    }
+}
\ No newline at end of file
diff --git a/PrettyPrinter.h b/PrettyPrinter.h
new file mode 100644
index 0000000..e6e5ef6
--- /dev/null
+++ b/PrettyPrinter.h
@@ -0,0 +1,57 @@
+// PrettyPrinter.h
+#ifndef PRETTY_PRINTER_H
+#define PRETTY_PRINTER_H
+
+#include "ast.h"
+#include <ostream>
+#include <functional>
+
+class PrettyPrinter {
+public:
+    explicit PrettyPrinter(std::ostream& os, int indentWidth = 4)
+            : out(os), indentWidth(indentWidth) {}
+
+    void print(ASTNode* root);
+
+private:
+    std::ostream& out;
+    int indentLevel = 0;
+    int indentWidth;
+
+    void indent();
+    void newline();
+    void withIndent(const std::function<void()>& f);
+
+    void printNode(ASTNode* n);
+
+    // 语句 & 翻译单元
+    void printTranslationUnit(ASTNode* n);
+    void printFunctionDef(ASTNode* n);
+    void printDeclStmt(ASTNode* n);
+    void printDeclaration(ASTNode* n);
+    void printIfStmt(ASTNode* n);
+    void printForStmt(ASTNode* n);
+    void printWhileStmt(ASTNode* n);
+    void printReturnStmt(ASTNode* n);
+    void printCompoundStmt(ASTNode* n);
+    void printInitDeclList(ASTNode* n);
+
+    // 表达式
+    void printExpr(ASTNode* n);
+    void printBinary(ASTNode* n, const char* op);
+    void printUnary(ASTNode* n, const char* op, bool prefix=true);
+    void printFuncCall(ASTNode* n);
+    void printArrayRef(ASTNode* n);
+    void printStructRef(ASTNode* n);
+
+
+    // 声明 & 类型
+    void printDeclSpec(ASTNode* n);
+    void printDeclarator(ASTNode* n);
+    void printParamList(ASTNode* n);
+
+    // 辅助
+    bool isStmt(ASTTag tag);
+};
+
+#endif // PRETTY_PRINTER_H
diff --git a/ast.cpp b/ast.cpp
new file mode 100644
index 0000000..0ddd09a
--- /dev/null
+++ b/ast.cpp
@@ -0,0 +1,809 @@
+#include "ast.h"
+#include <cstdlib>      // strtoll
+#include <cstring>
+
+/* ──────────────────────────
+ * 内部小工具
+ * ──────────────────────────*/
+namespace {
+    inline ASTNode* make(ASTTag tag) {
+        return new ASTNode(tag);
+    }
+
+    // 若左节点已经是某 tag 的列表，则直接 push；否则新建列表结点
+    ASTNode* append_to_list(ASTTag tag, ASTNode* list_or_node, ASTNode* item) {
+        if (list_or_node && list_or_node->tag == tag) {
+            list_or_node->kids.push_back(item);
+            return list_or_node;
+        }
+        auto* n = make(tag);
+        n->kids.reserve(4);
+        n->kids.push_back(list_or_node);
+        n->kids.push_back(item);
+        return n;
+    }
+}
+
+/* ──────────────────────────
+ * 基本原子节点
+ * ──────────────────────────*/
+ASTNode* new_id_node(const char* name, SourceLoc loc)
+{
+    auto* n = make(ASTTag::ID);
+    n->loc = loc;
+    n->text = name;
+    return n;
+}
+
+ASTNode* new_const_node(const char* literal, SourceLoc loc)
+{
+    auto* n = make(ASTTag::CONST);
+    n->loc = loc;
+    n->text = literal;
+    char* endp = nullptr;
+    n->ival = std::strtoll(literal, &endp, 0);
+    return n;
+}
+
+ASTNode* new_string_node(const char* literal, SourceLoc loc)
+{
+    auto* n = make(ASTTag::STRING);
+    n->loc = loc;
+    n->text = literal;
+    return n;
+}
+
+/* ──────────────────────────
+ * 后缀、调用、成员访问
+ * ──────────────────────────*/
+ASTNode* new_array_ref_node(ASTNode* array, ASTNode* index, SourceLoc loc)
+{
+    auto* n = make(ASTTag::ARRAY_REF);
+    n->kids = {array, index};
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_func_call_node(ASTNode* callee, ASTNode* arg_list, SourceLoc loc)
+{
+    auto* n = make(ASTTag::FUNC_CALL);
+    n->kids = {callee};
+    n->loc = loc;
+    if (arg_list) n->kids.push_back(arg_list);
+    return n;
+}
+
+ASTNode* new_struct_ref_node(ASTNode* base, const char* field, bool is_ptr_op, SourceLoc loc)
+{
+    auto* n = make(ASTTag::STRUCT_REF);
+    n->kids = {base};
+    n->loc = loc;
+    n->text = field;
+    n->flag = is_ptr_op;
+    return n;
+}
+
+/* ──────────────────────────
+ * 自增 / 复合字面量
+ * ──────────────────────────*/
+ASTNode* new_post_inc_node(ASTNode* expr, SourceLoc loc) {
+    auto* n = make(ASTTag::POST_INC);
+    n->kids = {expr};
+    n->loc = loc;
+    return n;
+}
+ASTNode* new_post_dec_node(ASTNode* expr, SourceLoc loc) {
+    auto* n = make(ASTTag::POST_DEC);
+    n->kids = {expr};
+    n->loc = loc;
+    return n;
+}
+ASTNode* new_pre_inc_node (ASTNode* expr, SourceLoc loc) {
+    auto* n = make(ASTTag::PRE_INC );
+    n->kids = {expr};
+    n->loc = loc;
+    return n;
+}
+ASTNode* new_pre_dec_node (ASTNode* expr, SourceLoc loc) {
+    auto* n = make(ASTTag::PRE_DEC );
+    n->kids = {expr};
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_compound_literal_node(ASTNode* type_name, ASTNode* init_list, SourceLoc loc)
+{
+    auto* n = make(ASTTag::COMPOUND_LITERAL);
+    n->kids = {type_name, init_list};
+    n->loc = loc;
+    return n;
+}
+
+/* ──────────────────────────
+ * 参数 / 实参与逗号表达式
+ * ──────────────────────────*/
+ASTNode* new_arg_list(ASTNode* first_arg, SourceLoc loc)
+{
+    auto* n = make(ASTTag::ARG_LIST);
+    n->kids.push_back(first_arg);
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* append_arg_list(ASTNode* list, ASTNode* arg, SourceLoc loc)
+{
+    ASTNode* n = append_to_list(ASTTag::ARG_LIST, list, arg);
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_expr_list(ASTNode* left, ASTNode* right, SourceLoc loc)
+{
+    ASTNode* n = append_to_list(ASTTag::ARG_LIST, left, right);
+    n->loc = loc;
+    return n;
+}
+
+/* ──────────────────────────
+ * 一元 / 二元 / 条件 / 逻辑 / 赋值
+ * ──────────────────────────*/
+ASTNode* new_unary_op_node(int op, ASTNode* operand, SourceLoc loc)
+{
+    auto* n = make(ASTTag::UNARY);
+    n->loc = loc;
+    n->ival = op;
+    n->kids = {operand};
+    return n;
+}
+
+ASTNode* new_sizeof_node(ASTNode* target, bool is_type_name, SourceLoc loc)
+{
+    auto* n = make(ASTTag::SIZEOF_EXPR);
+    n->flag = is_type_name;
+    n->loc = loc;
+    n->kids = {target};
+    return n;
+}
+
+ASTNode* new_cast_node(ASTNode* type_name, ASTNode* expr, SourceLoc loc)
+{
+    auto* n = make(ASTTag::CAST_EXPR);
+    n->kids = {type_name, expr};
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_binop_node(int op, ASTNode* lhs, ASTNode* rhs, SourceLoc loc)
+{
+    auto* n = make(ASTTag::BINARY);
+    n->loc = loc;
+    n->ival = op;
+    n->kids = {lhs, rhs};
+    return n;
+}
+
+ASTNode* new_logical_and_node(ASTNode* lhs, ASTNode* rhs, SourceLoc loc)
+{
+    auto* n = make(ASTTag::LOGIC_AND);
+    n->kids = {lhs, rhs};
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_logical_or_node(ASTNode* lhs, ASTNode* rhs, SourceLoc loc)
+{
+    auto* n = make(ASTTag::LOGIC_OR);
+    n->kids = {lhs, rhs};
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_conditional_node(ASTNode* cond, ASTNode* then_expr, ASTNode* else_expr, SourceLoc loc)
+{
+    auto* n = make(ASTTag::COND);
+    n->kids = {cond, then_expr, else_expr};
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_assign_node(ASTNode* lhs, int op, ASTNode* rhs, SourceLoc loc)
+{
+    auto* n = make(ASTTag::ASSIGN);
+    n->loc = loc;
+    n->ival = op;
+    n->kids = {lhs, rhs};
+    return n;
+}
+
+/* ──────────────────────────
+ * 4.  声明 & 类型系统
+ * ──────────────────────────*/
+static ASTNode* new_leaf(ASTTag list_tag, int enum_val, SourceLoc loc)
+{
+    auto* leaf = make(ASTTag::SPECIFIER);
+    leaf->ival = enum_val;
+    leaf->loc = loc;
+    return append_to_list(list_tag, nullptr, leaf);
+}
+
+/*—— 声明与说明符 ——*/
+ASTNode* new_spec_list(int spec, SourceLoc loc) {
+    return new_leaf(ASTTag::SPEC_LIST, spec, loc);
+}
+ASTNode* append_spec_list(ASTNode* list, int spec, SourceLoc loc) {
+    return append_to_list(ASTTag::SPEC_LIST, list, new_leaf(ASTTag::SPEC_LIST, spec, loc)->kids[0]);
+}
+
+ASTNode* new_declaration(ASTNode* spec_list, ASTNode* init_list, SourceLoc loc)
+{
+    auto* n = make(ASTTag::DECLARATION);
+    n->kids = {spec_list};
+    n->loc = loc;
+    if (init_list) n->kids.push_back(init_list);
+    return n;
+}
+
+/*—— init‑declarator 列表 ——*/
+ASTNode* new_init_decl(ASTNode* declarator, ASTNode* initializer, SourceLoc loc)
+{
+    auto* n = make(ASTTag::INIT_DECL);
+    n->kids = {declarator};
+    n->loc = loc;
+    if (initializer) n->kids.push_back(initializer);
+    return n;
+}
+ASTNode* new_init_list(ASTNode* init_decl, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::INIT_DECL_LIST,nullptr,init_decl);
+    n->loc = loc;
+    return n;
+}
+ASTNode* append_init_list(ASTNode* list, ASTNode* init_decl, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::INIT_DECL_LIST,list,init_decl);
+    n->loc = loc;
+    return n;
+}
+
+/*—— struct / union / enum ——*/
+ASTNode* new_struct_su_node(StructUnionKind su, const char* id, ASTNode* decl_list, SourceLoc loc)
+{
+    auto* n = make(ASTTag::SU_SPEC);
+    n->ival = su;
+    n->loc = loc;
+    if (id) n->text = id;
+    if (decl_list) n->kids.push_back(decl_list);
+    return n;
+}
+
+ASTNode* new_sdecl_list(ASTNode* sdecl, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::STRUCT_DECL_LIST,nullptr,sdecl);
+    n->loc = loc;
+    return n;
+}
+ASTNode* append_sdecl_list(ASTNode* list, ASTNode* sdecl, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::STRUCT_DECL_LIST, list, sdecl);
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_struct_decl(ASTNode* specq_list, ASTNode* sdecl_list, SourceLoc loc)
+{
+    auto* n = make(ASTTag::STRUCT_DECL);
+    n->kids = {specq_list, sdecl_list};
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_specq_list(int sq, SourceLoc loc) {
+    return new_leaf(ASTTag::SPECQ_LIST, sq, loc);
+}
+ASTNode* append_specq_list(ASTNode* list, int sq, SourceLoc loc) {
+    return append_to_list(ASTTag::SPECQ_LIST, list, new_leaf(ASTTag::SPECQ_LIST, sq, loc)->kids[0]);
+}
+
+ASTNode* new_sdeclarator_list(ASTNode* sdec, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::STRUCT_DECLARATOR_LIST,nullptr,sdec);
+    n->loc = loc;
+    return n;
+}
+ASTNode* append_sdeclarator_list(ASTNode* list, ASTNode* sdec, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::STRUCT_DECLARATOR_LIST, list, sdec);
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_bitfield_node(ASTNode* declarator, ASTNode* width, SourceLoc loc)
+{
+    auto* n = make(ASTTag::BITFIELD);
+    if (declarator) n->kids.push_back(declarator);
+    n->kids.push_back(width);
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_enum_node(const char* id, ASTNode* enumerator_list, SourceLoc loc)
+{
+    auto* n = make(ASTTag::ENUM_SPEC);
+    n->loc = loc;
+    if (id) n->text = id;
+    if (enumerator_list) n->kids.push_back(enumerator_list);
+    return n;
+}
+
+ASTNode* new_enum_const(const char* id, ASTNode* val, SourceLoc loc)
+{
+    auto* n = make(ASTTag::ENUM_CONST);
+    n->text = id;
+    n->loc = loc;
+    if (val) n->kids.push_back(val);
+    return n;
+}
+ASTNode* new_enum_list(ASTNode* e, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::ENUM_LIST,nullptr,e);
+    n->loc = loc;
+    return n;
+}
+ASTNode* append_enum_list(ASTNode* list, ASTNode* e, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::ENUM_LIST, list,e);
+    n->loc = loc;
+    return n;
+}
+
+/*—— 类型限定符列表 ——*/
+ASTNode* new_tq_list(int tq, SourceLoc loc) {
+    return new_leaf(ASTTag::TQ_LIST,tq, loc);
+}
+ASTNode* append_tq_list(ASTNode* list, int tq, SourceLoc loc) {
+    return append_to_list(ASTTag::TQ_LIST,list,new_leaf(ASTTag::TQ_LIST,tq, loc)->kids[0]);
+}
+
+/*—— declarator / pointer / array / func ——*/
+ASTNode* new_declarator_node(ASTNode* pointer, ASTNode* direct_decl, SourceLoc loc)
+{
+    auto* n = make(ASTTag::DECLARATOR);
+    if (pointer) n->kids.push_back(pointer);
+    n->kids.push_back(direct_decl);
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_decl_ident(const char* id, SourceLoc loc)
+{
+    auto* n = make(ASTTag::DECLARATOR);
+    n->text = id;
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_array_decl(ASTNode* decl, ASTNode* tq_list,
+                        ASTNode* size_expr, bool is_static, bool is_star, SourceLoc loc)
+{
+    auto* n = make(ASTTag::ARRAY_DECL);
+    n->kids = {decl};
+    n->loc = loc;
+    if (tq_list)     n->kids.push_back(tq_list);
+    if (size_expr)   n->kids.push_back(size_expr);
+    n->flag = is_static || is_star;   // 粗略放一起，用位标记也行
+    return n;
+}
+
+ASTNode* new_func_decl(ASTNode* decl, ASTNode* param_type_list, SourceLoc loc)
+{
+    auto* n = make(ASTTag::FUNC_DECL);
+    n->kids = {decl};
+    n->loc = loc;
+    if (param_type_list) n->kids.push_back(param_type_list);
+    return n;
+}
+ASTNode* new_oldstyle_func_decl(ASTNode* decl, ASTNode* id_list, SourceLoc loc)
+{
+    auto* n = make(ASTTag::OLD_FUNC_DECL);
+    n->kids = {decl, id_list};
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_pointer(ASTNode* tq_list, SourceLoc loc)
+{
+    auto* n = make(ASTTag::POINTER);
+    n->loc = loc;
+    if (tq_list) n->kids.push_back(tq_list);
+    return n;
+}
+
+ASTNode* prepend_pointer(ASTNode* tq_list, ASTNode* existing, SourceLoc loc)
+{
+    auto* n = make(ASTTag::POINTER);
+    n->loc = loc;
+    if (tq_list) n->kids.push_back(tq_list);
+    n->kids.push_back(existing);
+    return n;
+}
+
+/*—— 参数列表 & 声明 ——*/
+ASTNode* new_param_decl(ASTNode* decl_spec, ASTNode* declarator, SourceLoc loc)
+{
+    auto* n = make(ASTTag::PARAM_DECL);
+    n->kids = {decl_spec};
+    n->loc = loc;
+    if (declarator) n->kids.push_back(declarator);
+    return n;
+}
+ASTNode* new_param_list(ASTNode* p, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::PARAM_LIST,nullptr,p);
+    n->loc = loc;
+    return n;
+}
+ASTNode* append_param_list(ASTNode* list, ASTNode* p ,SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::PARAM_LIST,list,p);
+    n->loc = loc;
+    return n;
+}
+ASTNode* new_param_list_ellipsis(ASTNode* list, SourceLoc loc)
+{
+    auto* ellip = make(ASTTag::PARAM_LIST_ELIPS);
+    ellip->loc = loc;
+    return append_to_list(ASTTag::PARAM_LIST, list, ellip);
+}
+
+/*—— 标识符列表 ——*/
+ASTNode* new_id_list(const char* id, SourceLoc loc) {
+    return append_to_list(ASTTag::ID_LIST,nullptr,new_id_node(id, loc));
+}
+ASTNode* append_id_list(ASTNode* list, const char* id, SourceLoc loc) {
+    return append_to_list(ASTTag::ID_LIST,list,new_id_node(id, loc));
+}
+
+/*—— type‑name / 抽象声明符 ——*/
+ASTNode* new_type_name(ASTNode* specq_list, ASTNode* abs_decl, SourceLoc loc)
+{
+    auto* n = make(ASTTag::TYPE_NAME_NODE);
+    n->kids = {specq_list};
+    n->loc = loc;
+    if (abs_decl) n->kids.push_back(abs_decl);
+    return n;
+}
+
+ASTNode* new_abs_decl(ASTNode* pointer, ASTNode* direct_abs_decl, SourceLoc loc)
+{
+    auto* n = make(ASTTag::ABS_DECL);
+    n->loc = loc;
+    if (pointer) n->kids.push_back(pointer);
+    if (direct_abs_decl) n->kids.push_back(direct_abs_decl);
+    return n;
+}
+
+ASTNode* new_abs_array(ASTNode* size, bool is_star, SourceLoc loc)
+{
+    auto* n = make(ASTTag::ABS_ARRAY);
+    n->loc = loc;
+    if (size) n->kids.push_back(size);
+    n->flag = is_star;
+    return n;
+}
+ASTNode* new_abs_array_child(ASTNode* parent, ASTNode* size, bool is_star, SourceLoc loc)
+{
+    ASTNode* n = append_to_list(ASTTag::ABS_ARRAY_CHILD, parent, new_abs_array(size,is_star, loc));
+    n->loc = loc;
+    return n;
+}
+ASTNode* new_abs_func(ASTNode* param_list, SourceLoc loc)
+{
+    auto* n = make(ASTTag::ABS_FUNC);
+    n->loc = loc;
+    if (param_list) n->kids.push_back(param_list);
+    return n;
+}
+ASTNode* new_abs_func_child(ASTNode* parent, ASTNode* param_list, SourceLoc loc)
+{
+    ASTNode* n = append_to_list(ASTTag::ABS_FUNC_CHILD, parent, new_abs_func(param_list, loc));
+    n->loc = loc;
+    return n;
+}
+
+/* ──────────────────────────
+ * 5.  初始化 & 设计化初始化
+ * ──────────────────────────*/
+ASTNode* new_init_expr(ASTNode* expr, SourceLoc loc) {
+    auto* n = make(ASTTag::INIT_EXPR);
+    n->kids = {expr};
+    n->loc = loc;
+    return n;
+}
+ASTNode* new_init_item_list(ASTNode* init, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::INIT_ITEM_LIST,nullptr,init);
+    n->loc = loc;
+    return n;
+}
+ASTNode* append_init_item(ASTNode* list, ASTNode* init, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::INIT_ITEM_LIST,list,init);
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_init_list_node(ASTNode* item_list, SourceLoc loc)
+{
+    auto* n = make(ASTTag::INIT_LIST_NODE);
+    n->kids = {item_list};
+    n->loc = loc;
+    return n;
+}
+
+/*── 指定化初始化器 ──*/
+ASTNode* new_designator_list(ASTNode* d, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::DESIGNATOR_LIST,nullptr,d);
+    n->loc = loc;
+    return n;
+}
+ASTNode* append_designator_list(ASTNode* list, ASTNode* d, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::DESIGNATOR_LIST,list,d);
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_array_designator(ASTNode* const_expr, SourceLoc loc)
+{
+    auto* n = make(ASTTag::ARRAY_DESIGNATOR);
+    n->kids = {const_expr};
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_field_designator(const char* field, SourceLoc loc)
+{
+    auto* n = make(ASTTag::FIELD_DESIGNATOR);
+    n->text = field;
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_designated_init(ASTNode* designator_list, ASTNode* initializer, SourceLoc loc)
+{
+    auto* n = make(ASTTag::DESIGNATED_INIT);
+    n->kids = {designator_list, initializer};
+    n->loc = loc;
+    return n;
+}
+
+/* ──────────────────────────
+ * 6.  语句
+ * ──────────────────────────*/
+ASTNode* new_labeled_stmt_id(const char* id, ASTNode* stmt, SourceLoc loc) {
+    auto* n = make(ASTTag::LABELED_ID_STMT);
+    n->text=id;
+    n->loc = loc;
+    n->kids={stmt};
+    return n;
+}
+ASTNode* new_case_stmt(ASTNode* expr, ASTNode* stmt, SourceLoc loc) {
+    auto* n = make(ASTTag::CASE_STMT);
+    n->kids={expr,stmt};
+    n->loc = loc;
+    return n;
+}
+ASTNode* new_default_stmt(ASTNode* stmt, SourceLoc loc) {
+    auto* n = make(ASTTag::DEFAULT_STMT);
+    n->kids={stmt};
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_compound_stmt(ASTNode* block_item_list, SourceLoc loc)
+{
+    auto* n = make(ASTTag::COMPOUND_STMT);
+    n->loc = loc;
+    if (block_item_list) n->kids.push_back(block_item_list);
+    return n;
+}
+ASTNode* new_block_item_list(ASTNode* item, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::BLOCK_ITEM_LIST,nullptr,item);
+    n->loc = loc;
+    return n;
+}
+ASTNode* append_block_item_list(ASTNode* list, ASTNode* item, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::BLOCK_ITEM_LIST,list,item);
+    n->loc = loc;
+    return n;
+}
+ASTNode* new_block_decl(ASTNode* decl, SourceLoc loc) {
+    auto* n = make(ASTTag::BLOCK_DECL);
+    n->kids={decl};
+    n->loc = loc;
+    return n;
+}
+ASTNode* new_block_stmt(ASTNode* stmt, SourceLoc loc) {
+    auto* n = make(ASTTag::BLOCK_STMT);
+    n->kids={stmt};
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_expr_stmt(ASTNode* expr, SourceLoc loc) {
+    if(!expr) return make(ASTTag::EXPR_STMT);
+    auto* n=make(ASTTag::EXPR_STMT);
+    n->kids={expr};
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_if_stmt(ASTNode* cond, ASTNode* then_s, ASTNode* else_s, SourceLoc loc)
+{
+    auto* n = make(ASTTag::IF_STMT);
+    n->loc = loc;
+    n->kids = {cond, then_s};
+    if (else_s) n->kids.push_back(else_s);
+    return n;
+}
+
+ASTNode* new_switch_stmt(ASTNode* expr, ASTNode* body, SourceLoc loc) {
+    auto* n = make(ASTTag::SWITCH_STMT);
+    n->kids={expr,body};
+    n->loc = loc;
+    return n;
+}
+ASTNode* new_while_stmt(ASTNode* cond, ASTNode* body, SourceLoc loc) {
+    auto* n = make(ASTTag::WHILE_STMT);
+    n->kids={cond,body};
+    n->loc = loc;
+    return n;
+}
+ASTNode* new_do_while_stmt(ASTNode* body, ASTNode* cond, SourceLoc loc) {
+    auto* n = make(ASTTag::DO_WHILE_STMT);
+    n->kids={body,cond};
+    n->loc = loc;
+    return n;
+}
+
+ASTNode* new_for_stmt(ASTNode* init, ASTNode* cond, ASTNode* iter, ASTNode* body, SourceLoc loc)
+{
+    auto* n = make(ASTTag::FOR_STMT);
+    n->kids = {init, cond};
+    n->loc = loc;
+    if (iter) n->kids.push_back(iter);
+    n->kids.push_back(body);
+    return n;
+}
+
+ASTNode* new_for_decl_stmt(ASTNode* decl, ASTNode* cond, ASTNode* iter, ASTNode* body, SourceLoc loc)
+{
+    auto* n = make(ASTTag::FOR_DECL_STMT);
+    n->kids = {decl, cond};
+    n->loc = loc;
+    if (iter) n->kids.push_back(iter);
+    n->kids.push_back(body);
+    return n;
+}
+
+ASTNode* new_goto_stmt(const char* id, SourceLoc loc) {
+    auto* n = make(ASTTag::GOTO_STMT);
+    n->text=id;
+    n->loc = loc;
+    return n;
+}
+ASTNode* new_continue_stmt(SourceLoc loc) {
+    auto* n = make(ASTTag::CONTINUE_STMT);
+    n->loc = loc;
+    return n;
+}
+ASTNode* new_break_stmt(SourceLoc loc) {
+    auto* n = make(ASTTag::BREAK_STMT);
+    n->loc = loc;
+    return n;
+}
+ASTNode* new_return_stmt(ASTNode* expr, SourceLoc loc) {
+    auto* n = make(ASTTag::RETURN_STMT);
+    n->loc = loc;
+    if(expr)n->kids={expr};
+    return n;
+}
+
+/* ──────────────────────────
+ * 7.  翻译单元 / 顶层
+ * ──────────────────────────*/
+ASTNode* new_translation_unit(ASTNode* prev, ASTNode* ext_decl, SourceLoc loc)
+{
+    if (!prev) {
+        auto* n=make(ASTTag::TRANSL_UNIT);
+        n->kids={ext_decl};
+        n->loc = loc;
+        return n;
+    }
+    prev->kids.push_back(ext_decl);
+    return prev;
+}
+
+ASTNode* new_decl_stmt(ASTNode* declaration, SourceLoc loc)
+{
+    auto* n = make(ASTTag::DECL_STMT);
+    n->loc=loc;
+    n->kids={declaration};
+    return n;
+}
+
+ASTNode* new_function_def(ASTNode* decl_spec, ASTNode* declarator,
+                          ASTNode* decl_list, ASTNode* comp_stmt, SourceLoc loc)
+{
+    auto* n = make(ASTTag::FUNCTION_DEF);
+    n->loc=loc;
+    n->kids = {decl_spec, declarator};
+    if (decl_list) n->kids.push_back(decl_list);
+    n->kids.push_back(comp_stmt);
+    return n;
+}
+
+ASTNode* new_declaration_list(ASTNode* decl, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::DECL_LIST,nullptr,decl);
+    n->loc=loc;
+    return n;
+}
+ASTNode* append_declaration_list(ASTNode* list, ASTNode* decl, SourceLoc loc) {
+    ASTNode* n = append_to_list(ASTTag::DECL_LIST,list,decl);
+    n->loc=loc;
+    return n;
+}
+
+/*─────────  overload: enum ↔ node  ─────────*/
+
+ASTNode* new_spec_list(ASTNode* spec_node, SourceLoc loc)
+{
+    ASTNode* n = append_to_list(ASTTag::SPEC_LIST, nullptr, spec_node);
+    n->loc=loc;
+    return n;
+}
+ASTNode* append_spec_list(ASTNode* list, ASTNode* spec_node, SourceLoc loc)
+{
+    ASTNode* n = append_to_list(ASTTag::SPEC_LIST, list, spec_node);
+    n->loc=loc;
+    return n;
+}
+
+/* 设计化初始化: 追加 (designator = initializer) */
+ASTNode* append_designated_init(ASTNode* list,
+                                ASTNode* designator_list,
+                                ASTNode* initializer, SourceLoc loc)
+{
+    auto* di = new_designated_init(designator_list, initializer, loc);
+    return append_init_item(list, di, loc);
+}
+
+/* 若你用到了 specq_list，同理加 overload： */
+ASTNode* new_specq_list(ASTNode* node, SourceLoc loc)
+{
+    auto* n = append_to_list(ASTTag::SPECQ_LIST, nullptr, node);
+    n->loc=loc;
+    return n;
+}
+ASTNode* append_specq_list(ASTNode* list, ASTNode* node, SourceLoc loc)
+{
+    ASTNode* n = append_to_list(ASTTag::SPECQ_LIST, list, node);
+    n->loc=loc;
+    return n;
+
+}
+
+
+/* ── spec_list overload (node) ───────────────────────────*/
+// ASTNode* new_spec_list(ASTNode* spec_node) {
+//     return append_to_list(ASTTag::SPEC_LIST, nullptr, spec_node);
+// }
+// ASTNode* append_spec_list(ASTNode* list, ASTNode* spec_node) {
+//     return append_to_list(ASTTag::SPEC_LIST, list, spec_node);
+// }
+//
+// /* ── specq_list overload (node) ─────────────────────────*/
+// ASTNode* new_specq_list(ASTNode* node) {
+//     return append_to_list(ASTTag::SPECQ_LIST, nullptr, node);
+// }
+// ASTNode* append_specq_list(ASTNode* list, ASTNode* node) {
+//     return append_to_list(ASTTag::SPECQ_LIST, list, node);
+// }
+//
+// /* ── 追加指定化初始化器 ───────────────────────────────*/
+// ASTNode* append_designated_init(ASTNode* list,
+//                                 ASTNode* designator_list,
+//                                 ASTNode* initializer)
+// {
+//     return append_init_item(list,
+//             new_designated_init(designator_list, initializer));
+// }
+
+
diff --git a/ast.h b/ast.h
new file mode 100644
index 0000000..b80e5c5
--- /dev/null
+++ b/ast.h
@@ -0,0 +1,325 @@
+#ifndef MINI_C_AST_H
+#define MINI_C_AST_H
+
+#include <string>
+#include <vector>
+#include <cstdint>
+
+/*──────────────────────────────
+ * 0.  语义分析辅助
+ *─────────────────────────────*/
+
+// 在 type.h 中定义具体的 Type 类
+struct Type;
+
+// 用于记录 AST 节点在源文件中的行、列位置
+struct SourceLoc {
+    int line = 0;
+    int col  = 0;
+};
+
+/*──────────────────────────────
+ * 1.  词法‑语法层枚举
+ *─────────────────────────────*/
+//——单目运算符——
+enum UnaryOp : int {
+    op_address, op_deref, op_unary_plus, op_neg,
+    op_bitnot, op_not
+};
+
+//——赋值运算符（含复合）——
+enum AssignOp : int {
+    op_assign, op_mul_assign, op_div_assign, op_mod_assign,
+    op_add_assign, op_sub_assign, op_shl_assign, op_shr_assign,
+    op_and_assign, op_xor_assign, op_or_assign
+};
+
+//——额外二元运算符——
+enum BinaryOp : int {
+    // ASCII 运算符直接用字面字符
+    SHL = 256, SHR,
+    LE, GE, EQ, NE
+};
+
+//——存储类别说明符——
+enum StorageClass : int {
+    SC_TYPEDEF, SC_EXTERN, SC_STATIC, SC_AUTO, SC_REGISTER
+};
+
+//——基本类型说明符——
+enum TypeSpecifier : int {
+    TS_VOID, TS_CHAR, TS_SHORT, TS_INT, TS_LONG,
+    TS_FLOAT, TS_DOUBLE, TS_SIGNED, TS_UNSIGNED,
+    TS_BOOL, TS_COMPLEX, TS_IMAGINARY,
+    TS_TYPE_NAME            // typedef‑alias
+};
+
+//——struct / union——
+enum StructUnionKind : int { SU_STRUCT, SU_UNION };
+
+//——限定符 / 函数特性——
+enum TypeQualifier : int { TQ_CONST, TQ_RESTRICT, TQ_VOLATILE };
+enum FuncSpecifier : int { FS_INLINE };
+
+/*──────────────────────────────
+ * 2.  AST 结点与标签
+ *─────────────────────────────*/
+enum class ASTTag : std::uint16_t {
+    /*── 基本 / 运算类 ──*/
+    ID, CONST, STRING,
+    UNARY, BINARY, LOGIC_AND, LOGIC_OR,
+    COND, ASSIGN,
+    ARRAY_REF, STRUCT_REF, FUNC_CALL,
+    SIZEOF_EXPR, CAST_EXPR, COMPOUND_LITERAL,
+    EXPR_LIST, ARG_LIST,
+    PRE_INC,  PRE_DEC,      // ← 新增
+    POST_INC, POST_DEC,     // ← 新增
+    /*── 声明 & 类型 ──*/
+    SPECIFIER, SPEC_LIST, DECLARATION, INIT_DECL, INIT_DECL_LIST,
+    DECL_SPEC_LIST, DECLARATOR, POINTER_DECL,
+    ARRAY_DECL, FUNC_DECL, OLD_FUNC_DECL,
+    PARAM_DECL, PARAM_LIST, PARAM_LIST_ELIPS,
+    ID_LIST, TYPE_NAME_NODE,
+    ABS_DECL, ABS_ARRAY, ABS_ARRAY_CHILD,
+    ABS_FUNC, ABS_FUNC_CHILD,
+    POINTER, POINTER_CHAIN,
+    TQ_LIST,
+
+    /*── struct / enum ──*/
+    SU_SPEC, STRUCT_DECL, STRUCT_DECL_LIST,
+    STRUCT_DECLARATOR, STRUCT_DECLARATOR_LIST,
+    BITFIELD,
+    ENUM_SPEC, ENUM_LIST, ENUM_CONST,
+
+    SPECQ_LIST,
+
+    /*── 初始化 / 设计化初始化 ──*/
+    INIT_EXPR, INIT_LIST_NODE, INIT_ITEM_LIST,
+    DESIGNATOR_LIST, DESIGNATED_INIT,
+    ARRAY_DESIGNATOR, FIELD_DESIGNATOR,
+
+    /*── 语句 ──*/
+    LABELED_ID_STMT, CASE_STMT, DEFAULT_STMT,
+    COMPOUND_STMT, BLOCK_ITEM_LIST, BLOCK_DECL, BLOCK_STMT,
+    EXPR_STMT,
+    IF_STMT, SWITCH_STMT,
+    WHILE_STMT, DO_WHILE_STMT,
+    FOR_STMT, FOR_DECL_STMT,
+    GOTO_STMT, CONTINUE_STMT, BREAK_STMT, RETURN_STMT,
+
+    /*── 顶层 ──*/
+    TRANSL_UNIT, DECL_STMT, FUNCTION_DEF, DECL_LIST
+};
+
+struct ASTNode {
+    ASTTag                    tag;
+    std::string               text;     // 标识符
+    std::int64_t              ival{};   // 数值或枚举值
+    bool                      flag{};
+    SourceLoc                 loc{};    // 源代码行列信息
+    Type*                     type{};   // 语义分析后填充的类型指针
+    std::vector<ASTNode*>     kids;     // 子节点（按动作顺序）
+    explicit ASTNode(ASTTag t, SourceLoc loc_ = SourceLoc{})
+        : tag(t), loc(loc_) {}
+};
+
+/* 方便在别处直接引用整棵语法树 */
+extern ASTNode *ast_root;
+
+/*──────────────────────────────
+ * 3.  表达式构造函数
+ *─────────────────────────────*/
+ASTNode* new_id_node   (const char* name,   SourceLoc loc);
+ASTNode* new_const_node(const char* literal, SourceLoc loc);
+ASTNode* new_string_node(const char* literal, SourceLoc loc);
+
+ASTNode* new_array_ref_node(ASTNode* array, ASTNode* index, SourceLoc loc);
+ASTNode* new_func_call_node(ASTNode* callee, ASTNode* arg_list, SourceLoc loc);
+ASTNode* new_struct_ref_node(ASTNode* base, const char* field, bool is_ptr_op, SourceLoc loc);
+
+ASTNode* new_post_inc_node(ASTNode* expr, SourceLoc loc);
+ASTNode* new_post_dec_node(ASTNode* expr, SourceLoc loc);
+ASTNode* new_pre_inc_node(ASTNode* expr, SourceLoc loc);
+ASTNode* new_pre_dec_node(ASTNode* expr, SourceLoc loc);
+ASTNode* new_compound_literal_node(ASTNode* type_name, ASTNode* init_list, SourceLoc loc);
+
+ASTNode* new_arg_list(ASTNode* first_arg, SourceLoc loc);
+ASTNode* append_arg_list(ASTNode* list, ASTNode* arg, SourceLoc loc);
+
+ASTNode* new_unary_op_node(int op, ASTNode* operand, SourceLoc loc);
+ASTNode* new_sizeof_node(ASTNode* target, bool is_type_name, SourceLoc loc);
+ASTNode* new_cast_node(ASTNode* type_name, ASTNode* expr, SourceLoc loc);
+ASTNode* new_binop_node  (int op, ASTNode* lhs, ASTNode* rhs, SourceLoc loc);    // op 可为字符或 BinaryOp
+ASTNode* new_logical_and_node(ASTNode* lhs, ASTNode* rhs, SourceLoc loc);
+ASTNode* new_logical_or_node(ASTNode* lhs, ASTNode* rhs, SourceLoc loc);
+ASTNode* new_conditional_node(ASTNode* cond, ASTNode* then_expr, ASTNode* else_expr, SourceLoc loc);
+ASTNode* new_assign_node (ASTNode* lhs, int op, ASTNode* rhs, SourceLoc loc);
+
+ASTNode* new_expr_list(ASTNode* left, ASTNode* right, SourceLoc loc);
+
+/*──────────────────────────────
+ * 4.  声明 & 类型系统
+ *─────────────────────────────*/
+ASTNode* new_declaration(ASTNode* spec_list, ASTNode* init_list, SourceLoc loc);
+ASTNode* new_spec_list(int spec, SourceLoc loc);                   // 建立首节点
+ASTNode* append_spec_list(ASTNode* list, int spec, SourceLoc loc); // 追加
+
+ASTNode* new_init_list(ASTNode* init_decl, SourceLoc loc);
+ASTNode* append_init_list(ASTNode* list, ASTNode* init_decl, SourceLoc loc);
+ASTNode* new_init_decl(ASTNode* declarator, ASTNode* initializer, SourceLoc loc);
+
+ASTNode* new_struct_su_node(StructUnionKind su, const char* id, ASTNode* decl_list, SourceLoc loc);
+ASTNode* new_sdecl_list(ASTNode* sdecl, SourceLoc loc);
+ASTNode* append_sdecl_list(ASTNode* list, ASTNode* sdecl, SourceLoc loc);
+ASTNode* new_struct_decl(ASTNode* specq_list, ASTNode* sdecl_list, SourceLoc loc);
+
+ASTNode* new_specq_list(int spec_or_qual, SourceLoc loc);
+ASTNode* append_specq_list(ASTNode* list, int spec_or_qual, SourceLoc loc);
+
+ASTNode* new_sdeclarator_list(ASTNode* sdecltor, SourceLoc loc);
+ASTNode* append_sdeclarator_list(ASTNode* list, ASTNode* sdecltor, SourceLoc loc);
+
+ASTNode* new_bitfield_node(ASTNode* declarator /*nullable*/,
+                           ASTNode* width_expr, SourceLoc loc);
+
+ASTNode* new_enum_node(const char* id /*nullable*/, ASTNode* enumerator_list, SourceLoc loc);
+ASTNode* new_enum_list(ASTNode* enumerator, SourceLoc loc);
+ASTNode* append_enum_list(ASTNode* list, ASTNode* enumerator, SourceLoc loc);
+ASTNode* new_enum_const(const char* id, ASTNode* value_expr /*nullable*/, SourceLoc loc);
+
+ASTNode* new_tq_list(int tq, SourceLoc loc);
+ASTNode* append_tq_list(ASTNode* list, int tq, SourceLoc loc);
+
+ASTNode* new_declarator_node(ASTNode* pointer /*nullable*/, ASTNode* direct_decl, SourceLoc loc);
+ASTNode* new_decl_ident(const char* id, SourceLoc loc);
+ASTNode* new_array_decl(ASTNode* decl, ASTNode* tq_list /*nullable*/,
+                        ASTNode* size_expr /*nullable*/,
+                        bool is_static /*nullable*/,
+                        bool is_star /*nullable*/, SourceLoc loc);
+ASTNode* new_func_decl(ASTNode* decl, ASTNode* param_type_list /*nullable*/, SourceLoc loc);
+ASTNode* new_oldstyle_func_decl(ASTNode* decl, ASTNode* id_list, SourceLoc loc);
+
+ASTNode* new_pointer(ASTNode* tq_list /*nullable*/, SourceLoc loc);
+ASTNode* prepend_pointer(ASTNode* tq_list /*nullable*/, ASTNode* existing, SourceLoc loc);
+
+ASTNode* new_param_list(ASTNode* param_decl, SourceLoc loc);
+ASTNode* append_param_list(ASTNode* list, ASTNode* param_decl, SourceLoc loc);
+ASTNode* new_param_list_ellipsis(ASTNode* list, SourceLoc loc);
+ASTNode* new_param_decl(ASTNode* decl_spec, ASTNode* declarator /*nullable*/, SourceLoc loc);
+
+ASTNode* new_id_list(const char* id, SourceLoc loc);
+ASTNode* append_id_list(ASTNode* list, const char* id, SourceLoc loc);
+
+ASTNode* new_type_name(ASTNode* specq_list, ASTNode* abs_decl /*nullable*/, SourceLoc loc);
+
+ASTNode* new_abs_decl(ASTNode* pointer /*nullable*/, ASTNode* direct_abs_decl /*nullable*/, SourceLoc loc);
+ASTNode* new_abs_array(ASTNode* size_expr /*nullable*/, bool is_star /*nullable*/, SourceLoc loc);
+ASTNode* new_abs_array_child(ASTNode* parent, ASTNode* size_expr /*nullable*/, bool is_star /*nullable*/, SourceLoc loc);
+ASTNode* new_abs_func(ASTNode* param_type_list /*nullable*/, SourceLoc loc);
+ASTNode* new_abs_func_child(ASTNode* parent, ASTNode* param_type_list /*nullable*/, SourceLoc loc);
+
+/*──────────────────────────────
+ * 5.  初始化 & 设计化初始化
+ *─────────────────────────────*/
+ASTNode* new_init_expr(ASTNode* expr, SourceLoc loc);
+ASTNode* new_init_list_node(ASTNode* init_item_list, SourceLoc loc);
+ASTNode* new_init_item_list(ASTNode* initializer, SourceLoc loc);
+ASTNode* append_init_item(ASTNode* list, ASTNode* initializer, SourceLoc loc);
+
+ASTNode* new_designated_init(ASTNode* designator_list, ASTNode* initializer, SourceLoc loc);
+ASTNode* new_designator_list(ASTNode* designator, SourceLoc loc);
+ASTNode* append_designator_list(ASTNode* list, ASTNode* designator, SourceLoc loc);
+ASTNode* new_array_designator(ASTNode* const_expr, SourceLoc loc);
+ASTNode* new_field_designator(const char* field, SourceLoc loc);
+
+/*──────────────────────────────
+ * 6.  语句
+ *─────────────────────────────*/
+ASTNode* new_labeled_stmt_id(const char* id, ASTNode* stmt, SourceLoc loc);
+ASTNode* new_case_stmt(ASTNode* const_expr, ASTNode* stmt, SourceLoc loc);
+ASTNode* new_default_stmt(ASTNode* stmt, SourceLoc loc);
+
+ASTNode* new_compound_stmt(ASTNode* block_item_list /*nullable*/, SourceLoc loc);
+ASTNode* new_block_item_list(ASTNode* item, SourceLoc loc);
+ASTNode* append_block_item_list(ASTNode* list, ASTNode* item, SourceLoc loc);
+ASTNode* new_block_decl(ASTNode* decl, SourceLoc loc);
+ASTNode* new_block_stmt(ASTNode* stmt, SourceLoc loc);
+
+ASTNode* new_expr_stmt(ASTNode* expr /*nullable*/, SourceLoc loc);
+
+ASTNode* new_if_stmt(ASTNode* cond, ASTNode* then_stmt, ASTNode* else_stmt /*nullable*/, SourceLoc loc);
+ASTNode* new_switch_stmt(ASTNode* expr, ASTNode* stmt, SourceLoc loc);
+
+ASTNode* new_while_stmt(ASTNode* cond, ASTNode* body, SourceLoc loc);
+ASTNode* new_do_while_stmt(ASTNode* body, ASTNode* cond, SourceLoc loc);
+ASTNode* new_for_stmt(ASTNode* init, ASTNode* cond, ASTNode* iter /*nullable*/, ASTNode* body, SourceLoc loc);
+ASTNode* new_for_decl_stmt(ASTNode* decl, ASTNode* cond_expr_stmt,
+                           ASTNode* iter_expr /*nullable*/, ASTNode* body, SourceLoc loc);
+
+ASTNode* new_goto_stmt(const char* id, SourceLoc loc);
+ASTNode* new_continue_stmt(SourceLoc loc);
+ASTNode* new_break_stmt(SourceLoc loc);
+ASTNode* new_return_stmt  (ASTNode* expr /*nullable*/, SourceLoc loc);
+
+/*──────────────────────────────
+ * 7.  翻译单元 / 顶层
+ *─────────────────────────────*/
+ASTNode* new_translation_unit(ASTNode* prev, ASTNode* ext_decl, SourceLoc loc);
+ASTNode* new_decl_stmt    (ASTNode* declaration, SourceLoc loc);
+ASTNode* new_function_def (ASTNode* decl_spec, ASTNode* declarator,
+                           ASTNode* decl_list /*nullable*/, ASTNode* compound_stmt,
+                           SourceLoc loc);
+
+ASTNode* new_declaration_list(ASTNode* decl, SourceLoc loc);
+ASTNode* append_declaration_list(ASTNode* list, ASTNode* decl, SourceLoc loc);
+
+// ★ 放在初始化区域旁边
+ASTNode* append_designated_init(ASTNode* list,
+                                ASTNode* designator_list,
+                                ASTNode* initializer, SourceLoc loc);
+
+// ★ 新增两种 overload，让既能接 enum 也能接节点
+ASTNode* new_spec_list(ASTNode* spec_node, SourceLoc loc);
+ASTNode* append_spec_list(ASTNode* list, ASTNode* spec_node, SourceLoc loc);
+
+
+/* 让列表函数既接受 enum 也接受 ASTNode* -------------------*/
+// ASTNode* (ASTNode* spec_node);
+ASTNode* append_spec_list(ASTNode* list, ASTNode* spec_node, SourceLoc loc);
+
+ASTNode* new_specq_list(ASTNode* node, SourceLoc loc);
+ASTNode* append_specq_list(ASTNode* list, ASTNode* node, SourceLoc loc);
+
+static std::string extractNameFromDeclarator(ASTNode* dtor) {
+    std::string name = "";
+    if (!dtor) return name;
+
+    ASTNode* current = dtor;
+    // 循环查找，直到找到带 text 的 DECLARATOR 或 ID
+    while (current) {
+        if (current->tag == ASTTag::DECLARATOR && !current->text.empty()) {
+            name = current->text;
+            break;
+        }
+        if (current->tag == ASTTag::ID) {
+            name = current->text;
+            break;
+        }
+        // 如果当前节点是 DECLARATOR 或 FUNC_DECL 且有子节点，则深入第一个子节点
+        // （这部分逻辑需要根据 AST 结构仔细调整）
+        if ((current->tag == ASTTag::DECLARATOR || current->tag == ASTTag::FUNC_DECL) && !current->kids.empty()) {
+            // 特殊处理函数名情况：FUNC_DECL -> DECLARATOR "name"
+            if (current->tag == ASTTag::FUNC_DECL && current->kids[0] && current->kids[0]->tag == ASTTag::DECLARATOR && !current->kids[0]->text.empty()) {
+                name = current->kids[0]->text;
+                break;
+            }
+            current = current->kids[0]; // 默认深入第一个孩子
+        } else {
+            break; // 无法继续深入
+        }
+    }
+    return name;
+}
+
+
+#endif /* MINI_C_AST_H */
diff --git a/interpreter.cpp b/interpreter.cpp
new file mode 100644
index 0000000..f584c22
--- /dev/null
+++ b/interpreter.cpp
@@ -0,0 +1,364 @@
+#include "interpreter.h"
+#include <cctype>
+#include <sstream>
+
+
+int IRInterpreter::asInt(const std::string& s) {
+    if (s.empty()) return 0;
+    if (isdigit(s[0]) || (s[0] == '-' && s.size() > 1 && isdigit(s[1]))) {
+        return std::stoi(s);
+    }
+    return 0;
+}
+
+
+
+std::string IRInterpreter::asStr(const std::string& s) {
+    if (s.size() >= 2 && s.front() == '"' && s.back() == '"') {
+        return s.substr(1, s.size() - 2);
+    } else if (memory_.count(s) && std::holds_alternative<std::string>(memory_[s])) {
+        return std::get<std::string>(memory_[s]);
+    }
+    return s;
+}
+
+void IRInterpreter::runStepByStep(const std::vector<Quad>& quads) {
+    // 建立 label -> index 映射 (用于控制流跳转)
+    std::unordered_map<std::string, int> labelToIndex;
+    for (int i = 0; i < quads.size(); ++i) {
+        if (quads[i].op == "label") {
+            labelToIndex[quads[i].result] = i;
+        }
+    }
+
+    std::string cmd;
+
+    while (pc_ < quads.size()) {
+        const auto& q = quads[pc_];
+
+        if (breakpoints_.count(q.loc.line)) {
+            std::cout << "🟥 Breakpoint hit at line " << q.loc.line << "\n";
+            dumpVariables(q.loc.line);
+
+            // ⚠️关键修复：命中断点时立刻执行当前指令！
+            execute(q, quads, labelToIndex);
+
+            pc_++;
+
+            // 如果下一条指令属于同一行，也立刻执行，避免二次命中断点
+            while (pc_ < quads.size() && quads[pc_].loc.line == q.loc.line) {
+                execute(quads[pc_], quads, labelToIndex);
+                pc_++;
+            }
+            continue;
+        }
+
+        // 显示当前指令
+        std::cout << "[PC " << pc_ << "] " << q.op << " " << q.arg1 << " " << q.arg2 << " -> " << q.result;
+        std::cout << " @ line " << q.loc.line << "\n";
+        std::cout << "(step> ";
+        std::getline(std::cin, cmd);
+
+        if (cmd == "next" || cmd == "n") {
+            execute(q, quads, labelToIndex); pc_++;
+        }
+        else if (cmd.starts_with("break ")) {
+            int line = std::stoi(cmd.substr(6));
+            breakpoints_.insert(line);
+            std::cout << "✅ Breakpoint set at line " << line << "\n";
+        }
+        else if (cmd == "continue" || cmd == "c") {
+            // 先执行当前指令
+            execute(q, quads, labelToIndex); pc_++;
+
+            while (pc_ < quads.size()) {
+                const auto& current = quads[pc_];
+
+                if (breakpoints_.count(current.loc.line)) {
+                    std::cout << "🟥 Breakpoint hit at line " << current.loc.line << "\n";
+                    dumpVariables(current.loc.line);
+
+                    // ⚠️关键修复：命中断点立刻执行当前指令！
+                    execute(current, quads, labelToIndex); pc_++;
+
+                    // 若下一条同一行，也执行
+                    while (pc_ < quads.size() && quads[pc_].loc.line == current.loc.line) {
+                        execute(quads[pc_], quads, labelToIndex);
+                        pc_++;
+                    }
+
+                    break;
+                }
+
+                execute(current,quads, labelToIndex);
+
+                // 处理控制流
+                if (current.op == "goto") {
+                    pc_ = labelToIndex[current.result];
+                } else if (current.op == "ifFalse") {
+                    int cond = memory_.count(current.arg1) ? std::get<int>(memory_[current.arg1]) : asInt(current.arg1);
+                    pc_ = cond ? pc_ + 1 : labelToIndex[current.result];
+                } else if (current.op == "ifTrue") {
+                    int cond = memory_.count(current.arg1) ? std::get<int>(memory_[current.arg1]) : asInt(current.arg1);
+                    pc_ = cond ? labelToIndex[current.result] : pc_ + 1;
+                } else {
+                    pc_++;
+                }
+            }
+        }
+        else if (cmd == "print") {
+            dumpVariables(q.loc.line);
+        }
+        else if (cmd == "exit" || cmd == "q") {
+            std::cout << "👋 Exiting...\n";
+            break;
+        }
+        else {
+            std::cout << "❓ Unknown command: " << cmd << "\n";
+        }
+    }
+}
+
+
+
+
+
+
+
+
+IRInterpreter::Value IRInterpreter::evalBinary(const std::string& op, const Value& a, const Value& b) {
+    if (std::holds_alternative<int>(a) && std::holds_alternative<int>(b)) {
+        int x = std::get<int>(a), y = std::get<int>(b);
+        if (op == "+") return x + y;
+        if (op == "-") return x - y;
+        if (op == "*") return x * y;
+        if (op == "/") return y != 0 ? x / y : 0;
+        if (op == "<") return x < y;
+        if (op == ">") return x > y;
+        if (op == "==") return x == y;
+        if (op == "!=") return x != y;
+        if (op == "&&") return x && y;
+        if (op == "||") return x || y;
+    }
+    return 0;
+}
+
+std::string IRInterpreter::findLastSource(const std::vector<Quad>& quads, const std::string& target) {
+    for (auto it = quads.rbegin(); it != quads.rend(); ++it) {
+        if (it->result == target && !it->arg1.empty()) {
+            return it->arg1;
+        }
+    }
+    return "";
+}
+
+void IRInterpreter::execute(const Quad& q,
+                            const std::vector<Quad>& quads,
+                            const std::unordered_map<std::string, int>& labelToIndex) {
+    // 类型记录
+    if (!q.result.empty() && q.type) {
+        types_[q.result] = q.type;
+    }
+
+
+    if (q.op == "=") {
+        if (q.arg1.empty()) {
+            memory_.emplace(q.result, 0);
+        } else if (q.arg1[0] == '"') {
+            memory_[q.result] = asStr(q.arg1);
+        } else if (isdigit(q.arg1[0]) || (q.arg1[0] == '-' && isdigit(q.arg1[1]))) {
+            memory_[q.result] = std::stoi(q.arg1);
+        } else {
+            memory_[q.result] = memory_.count(q.arg1) ? memory_[q.arg1] : 0;
+        }
+    }
+
+    else if (q.op == "+" || q.op == "-" || q.op == "*" || q.op == "/" ||
+             q.op == "<" || q.op == ">" || q.op == "==" || q.op == "!=" ||
+             q.op == "&&" || q.op == "||") {
+
+        Value valA = memory_.count(q.arg1) ? memory_[q.arg1] : asInt(q.arg1);
+        Value valB = memory_.count(q.arg2) ? memory_[q.arg2] : asInt(q.arg2);
+        memory_[q.result] = evalBinary(q.op, valA, valB);
+             }
+
+    else if (q.op == "!") {
+        int val = asInt(q.arg1);
+        memory_[q.result] = !val;
+    }
+
+    else if (q.op == "label" || q.op == "goto" || q.op == "ifTrue" || q.op == "ifFalse") {
+        // 控制流不处理，外部 runStepByStep() 会处理 PC 跳转
+    }
+
+    // else if (q.op == "param" || q.op == "call" || q.op == "return") {
+    //     std::cout << "[WARN] Function-related op '" << q.op << "' not yet supported.\n";
+    // }
+
+
+    else if (q.op == "param") {
+        Value val = memory_.count(q.arg1) ? memory_[q.arg1] : asInt(q.arg1);
+        paramStack_.push_back(val);
+    }
+
+    else if (q.op == "call") {
+        CallFrame frame;
+        frame.return_pc = pc_ + 1;
+        frame.locals = memory_;  // 保存当前变量环境
+
+        callStack_.push(frame);
+        memory_.clear();
+
+        int num_args = std::stoi(q.arg2);
+        auto it = labelToIndex.find(q.arg1);
+        if (it == labelToIndex.end()) {
+            std::cerr << "[ERROR] Undefined function: " << q.arg1 << "\n";
+            return;
+        }
+
+        pc_ = it->second + 1; // 跳转到函数标签下一条指令
+
+        // 传递参数到函数内部
+        for (int i = num_args - 1; i >= 0; --i) {
+            memory_["arg" + std::to_string(i)] = paramStack_.back();
+            paramStack_.pop_back();
+        }
+    }
+
+    else if (q.op == "return") {
+        Value ret_val = memory_.count(q.arg1) ? memory_[q.arg1] : asInt(q.arg1);
+
+        if (callStack_.empty()) {
+            std::cerr << "[ERROR] Return outside function!\n";
+            return;
+        }
+
+        CallFrame frame = callStack_.top();
+        callStack_.pop();
+
+        memory_ = frame.locals;  // 恢复调用函数前的内存环境
+
+        // 将返回值存入指定变量中（如果call指令有返回值）
+        if (!quads[frame.return_pc - 1].result.empty()) {
+            memory_[quads[frame.return_pc - 1].result] = ret_val;
+        }
+
+        pc_ = frame.return_pc;  // 返回调用位置继续执行
+    }
+
+
+
+
+
+    else {
+        std::cerr << "[ERROR] Unknown op: " << q.op << "\n";
+    }
+}
+
+
+
+void IRInterpreter::runUntil(const std::vector<Quad>& quads, int breakLine) {
+    // 建立 label -> index 映射
+    std::unordered_map<std::string, int> labelToIndex;
+    for (int i = 0; i < quads.size(); ++i) {
+        if (quads[i].op == "label") {
+            labelToIndex[quads[i].result] = i;
+        }
+    }
+
+    int pc = 0;
+    while (pc < quads.size()) {
+        const auto& q = quads[pc];
+        std::cout << "[PC " << pc << "] line = " << q.loc.line << ", breakLine = " << breakLine << "\n";
+        if (q.loc.line >= breakLine) break;
+
+        std::cout << "[EXEC] " << q.op << " " << q.arg1 << " " << q.arg2 << " -> " << q.result << "\n";
+
+        if (!q.result.empty() && q.type) {
+            types_[q.result] = q.type;
+        }
+
+        if (q.op == "=") {
+            if (q.arg1.empty()) {
+                memory_.emplace(q.result, 0);
+            } else if (q.arg1[0] == '"') {
+                memory_[q.result] = asStr(q.arg1);
+            } else if (isdigit(q.arg1[0]) || (q.arg1[0] == '-' && isdigit(q.arg1[1]))) {
+                memory_[q.result] = std::stoi(q.arg1);
+            } else {
+                memory_[q.result] = memory_.count(q.arg1) ? memory_[q.arg1] : 0;
+            }
+        }
+        else if (q.op == "+" || q.op == "-" || q.op == "*" || q.op == "/" ||
+                 q.op == "<" || q.op == ">" || q.op == "==" || q.op == "!=" ||
+                 q.op == "&&" || q.op == "||") {
+            Value valA = memory_.count(q.arg1) ? memory_[q.arg1] : asInt(q.arg1);
+            Value valB = memory_.count(q.arg2) ? memory_[q.arg2] : asInt(q.arg2);
+            memory_[q.result] = evalBinary(q.op, valA, valB);
+        }
+        else if (q.op == "!") {
+            int val = asInt(q.arg1);
+            memory_[q.result] = !val;
+        }
+        else if (q.op == "ifFalse") {
+            int cond = memory_.count(q.arg1) ? std::get<int>(memory_[q.arg1]) : asInt(q.arg1);
+            if (!cond) {
+                pc = labelToIndex[q.result];
+                continue;
+            }
+        }
+        else if (q.op == "ifTrue") {
+            int cond = memory_.count(q.arg1) ? std::get<int>(memory_[q.arg1]) : asInt(q.arg1);
+            if (cond) {
+                pc = labelToIndex[q.result];
+                continue;
+            }
+        }
+
+        else if (q.op == "goto") {
+            std::cout << "[DEBUG] Handling goto to " << q.result << "\n";
+            auto it = labelToIndex.find(q.result);
+            if (it != labelToIndex.end()) {
+                pc = it->second;
+                continue;
+            } else {
+                std::cerr << "[ERROR] Unknown label: " << q.result << "\n";
+            }
+        }
+
+
+        else if (q.op == "label") {
+            // do nothing
+        }
+        else if (q.op == "param" || q.op == "call" || q.op == "return") {
+            // 留给下一阶段实现函数调用
+        }
+
+        pc++;  // 正常执行下一条
+    }
+
+    dumpVariables(breakLine);
+}
+
+
+void IRInterpreter::dumpVariables(int breakLine) {
+    std::cout << "\n---- Variables before line " << breakLine << " ----\n";
+    for (const auto& [name, val] : memory_) {
+        // 忽略以 "t" 开头的临时变量（比如 t1, t2）
+        if (!name.empty() && name[0] == 't' && isdigit(name[1])) continue;
+
+        std::cout << name << " = ";
+        if (std::holds_alternative<int>(val)) {
+            std::cout << std::get<int>(val);
+        } else if (std::holds_alternative<std::string>(val)) {
+            std::cout << "\"" << std::get<std::string>(val) << "\"";
+        }
+
+        if (types_.count(name)) {
+            std::cout << "  (type = " << types_[name]->toString() << ")";
+        }
+
+        std::cout << "\n";
+    }
+}
+
diff --git a/interpreter.h b/interpreter.h
new file mode 100644
index 0000000..84bc15b
--- /dev/null
+++ b/interpreter.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "ir.h"
+#include <unordered_map>
+#include <variant>
+#include <string>
+#include <vector>
+#include <iostream>
+#include <unordered_set>
+
+
+
+class IRInterpreter {
+public:
+    void runUntil(const std::vector<Quad>& quads, int breakLine);
+    void runStepByStep(const std::vector<Quad>& quads);
+    void execute(const Quad& q,
+                            const std::vector<Quad>& quads,
+                            const std::unordered_map<std::string, int>& labelToIndex);
+    std::string findLastSource(const std::vector<Quad>& quads, const std::string& target);
+    using Value = std::variant<int, std::string>;
+    struct CallFrame {
+        int return_pc;
+        std::unordered_map<std::string, Value> locals;
+    };
+    Value getOrZero(const std::string& name);
+    std::unordered_map<std::string, Value> memory_;
+    std::unordered_map<std::string, TypePtr> types_;
+    int pc_ = 0;
+    std::unordered_set<int> breakpoints_;
+    int lastBreakpointPC = -1;  // 在类中记录
+    int asInt(const std::string& s);
+    std::string asStr(const std::string& s);
+    Value evalBinary(const std::string& op, const Value& a, const Value& b);
+    void dumpVariables(int breakLine);
+    std::stack<CallFrame> callStack_;
+    std::vector<Value> paramStack_;
+    std::unordered_map<std::string, int> labelToIndex_;
+    std::vector<Quad> quads_;
+};
+
diff --git a/ir.cpp b/ir.cpp
new file mode 100644
index 0000000..932d99f
--- /dev/null
+++ b/ir.cpp
@@ -0,0 +1,612 @@
+// ir.cpp
+#include "ir.h"
+#include "ast.h"
+#include <cassert>
+#include <iostream>
+
+#include "symbol.h"
+
+
+
+
+
+void dumpAST(ASTNode* n, int indent = 0) {
+    if (!n) return;
+    std::string pad(indent, ' ');
+    // std::cout << pad << "Tag = " << static_cast<int>(n->tag) << ", text = " << n->text << ", loc = (" << n->loc.line << "," << n->loc.col << ")\n";
+    for (auto* c : n->kids) dumpAST(c, indent + 2);
+}
+
+
+// 生成入口
+std::vector<Quad> IRGenerator::generate(ASTNode* root) {
+    if (!currentScope_) {
+        std::cerr << "FATAL ERROR in IRGenerator::generate: currentScope_ is null at entry!" << std::endl;
+        return {}; // 返回空列表
+    }
+    dumpAST(root);
+    quads_.clear();
+    breakLabels_.clear();
+    continueLabels_.clear();
+    lastLoc_ = {0,0};
+    genStmt(root);
+    for (const auto& q : quads_) {
+        // std::cout << "[IR] " << q.op << " " << q.arg1 << " " << q.arg2 << " -> " << q.result << "\n";
+    }
+    return quads_;
+}
+
+void IRGenerator::recordLoc(SourceLoc loc) {
+    lastLoc_ = loc;
+}
+
+// 表达式生成，返回“这个表达式结果”的变量名（临时或直接变量）
+std::string IRGenerator::genExpr(ASTNode* n) {
+    if (!n) return "";
+
+    // 每次真正用到 n->loc 的时候先记录：
+    recordLoc(n->loc);
+
+    switch (n->tag) {
+        case ASTTag::CONST: {
+            std::string t = newTemp();
+            TypePtr ty = std::make_shared<BasicType>(TS_INT);
+            emit("=", n->text, "", t, lastLoc_, /*var=*/"", ty);
+            tempTypes_[t] = ty;
+            return t;
+        }
+        case ASTTag::ID: {
+            auto *sym = symbolTable_->lookup(n->text);
+            if (sym) tempTypes_[n->text] = sym->type;
+            return n->text;
+        }
+
+        case ASTTag::UNARY: {
+            std::string src = genExpr(n->kids[0]);
+            std::string t   = newTemp();
+            std::string op;
+            switch (static_cast<UnaryOp>(n->ival)) {
+                case op_address:    op = "addr";   break;
+                case op_deref:      op = "deref";  break;
+                case op_unary_plus: op = "+";      break;
+                case op_neg:        op = "-";      break;
+                case op_bitnot:     op = "~";      break;
+                case op_not:        op = "!";      break;
+            }
+            TypePtr ty = tempTypes_[src];
+            emit(op, src, "", t, lastLoc_, "", ty);
+            tempTypes_[t] = ty;
+            return t;
+        }
+
+        case ASTTag::BINARY: {
+            std::string lhs = genExpr(n->kids[0]);
+            std::string rhs = genExpr(n->kids[1]);
+            std::string t   = newTemp();
+            int opv = n->ival;
+            std::string op;
+
+            if (opv < 256) {
+                op = std::string(1, static_cast<char>(opv));
+            } else {
+                switch (static_cast<BinaryOp>(opv)) {
+                    case SHL: op = "<<"; break;
+                    case SHR: op = ">>"; break;
+                    case LE:  op = "<="; break;
+                    case GE:  op = ">="; break;
+                    case EQ:  op = "=="; break;
+                    case NE:  op = "!="; break;
+                    default:  op = "?";  break;
+                }
+            }
+
+            TypePtr ty = tempTypes_[lhs];
+            emit(op, lhs, rhs, t, lastLoc_, "", ty);
+            tempTypes_[t] = ty;
+            return t;
+        }
+
+        case ASTTag::LOGIC_AND: {
+            std::string L_false = newLabel();
+            std::string L_end   = newLabel();
+            std::string t       = newTemp();
+            TypePtr ty = std::make_shared<BasicType>(TS_INT);
+
+            emit("=", "1", "", t, lastLoc_, "", ty);
+
+            std::string a = genExpr(n->kids[0]);
+            emit("ifFalse", a, "", L_false, lastLoc_);
+
+            std::string b = genExpr(n->kids[1]);
+            emit("ifFalse", b, "", L_false, lastLoc_);
+
+            emit("goto", "", "", L_end, lastLoc_);
+            emit("label", "", "", L_false, lastLoc_);
+
+            emit("=", "0", "", t, lastLoc_, "", ty);
+            emit("label", "", "", L_end, lastLoc_);
+
+            tempTypes_[t] = ty;
+            return t;
+        }
+
+        case ASTTag::LOGIC_OR: {
+            std::string L_true  = newLabel();
+            std::string L_end   = newLabel();
+            std::string t       = newTemp();
+            TypePtr ty = std::make_shared<BasicType>(TS_INT);
+
+            emit("=", "0", "", t, lastLoc_, "", ty);
+
+            std::string a = genExpr(n->kids[0]);
+            emit("ifTrue", a, "", L_true, lastLoc_);
+
+            std::string b = genExpr(n->kids[1]);
+            emit("ifTrue", b, "", L_true, lastLoc_);
+
+            emit("goto", "", "", L_end, lastLoc_);
+            emit("label", "", "", L_true, lastLoc_);
+
+            emit("=", "1", "", t, lastLoc_, "", ty);
+            emit("label", "", "", L_end, lastLoc_);
+
+            tempTypes_[t] = ty;
+            return t;
+        }
+
+        case ASTTag::COND: {
+            std::string L_false = newLabel();
+            std::string L_end   = newLabel();
+            std::string t       = newTemp();
+
+            std::string c = genExpr(n->kids[0]);
+            emit("ifFalse", c, "", L_false, lastLoc_);
+
+            std::string r1 = genExpr(n->kids[1]);
+            emit("=", r1, "", t, lastLoc_, "", tempTypes_[r1]);
+
+            emit("goto", "", "", L_end, lastLoc_);
+            emit("label", "", "", L_false, lastLoc_);
+
+            std::string r2 = genExpr(n->kids[2]);
+            emit("=", r2, "", t, lastLoc_, "", tempTypes_[r2]);
+
+            emit("label", "", "", L_end, lastLoc_);
+
+            tempTypes_[t] = tempTypes_[r1];  // 或某种 merge 类型推导
+            return t;
+        }
+
+        case ASTTag::ASSIGN: {
+            std::string rhs = genExpr(n->kids[1]);
+            std::string lhs = genExpr(n->kids[0]);
+            auto *sym = symbolTable_->lookup(lhs);
+            TypePtr vtype = sym ? sym->type : tempTypes_[rhs];
+            emit("=", rhs, "", lhs, lastLoc_, lhs, vtype);
+            return lhs;
+        }
+
+        case ASTTag::ARRAY_REF: {
+            std::string base = genExpr(n->kids[0]);
+            std::string idx  = genExpr(n->kids[1]);
+            std::string t    = newTemp();
+            emit("[]", base, idx, t, lastLoc_, "", tempTypes_[base]);
+            tempTypes_[t] = tempTypes_[base];
+            return t;
+        }
+
+        case ASTTag::STRUCT_REF: {
+            std::string base = genExpr(n->kids[0]);
+            std::string fld  = n->text;
+            std::string t    = newTemp();
+            emit(n->flag ? "->" : ".", base, fld, t, lastLoc_, "", tempTypes_[base]);
+            tempTypes_[t] = tempTypes_[base];
+            return t;
+        }
+
+        case ASTTag::FUNC_CALL: {
+            if (n->kids.size() == 2) {
+                for (auto* a : n->kids[1]->kids) {
+                    std::string tmp = genExpr(a);
+                    emit("param", tmp, "", "", lastLoc_, "", tempTypes_[tmp]);
+                }
+            }
+            std::string ret = newTemp();
+            int argc = (n->kids.size() == 2 ? n->kids[1]->kids.size() : 0);
+            emit("call", n->kids[0]->text, std::to_string(argc), ret, lastLoc_, "", nullptr);
+            return ret;
+        }
+
+        case ASTTag::STRING: {
+            std::string t = newTemp();
+            TypePtr ty = std::make_shared<PointerType>(std::make_shared<BasicType>(TS_CHAR));
+            emit("=", n->text, "", t, lastLoc_, "", ty);
+            tempTypes_[t] = ty;
+            return t;
+        }
+
+        case ASTTag::EXPR_LIST: {
+            genExpr(n->kids[0]);
+            return genExpr(n->kids[1]);
+        }
+
+        case ASTTag::INIT_EXPR: {
+            if (!n->kids.empty()) {
+                return genExpr(n->kids[0]);  // unwrap INIT_EXPR 包装，递归实际表达式
+            }
+            return "";
+        }
+
+
+        default:
+            for (auto* c : n->kids) genExpr(c);
+            return "";
+    }
+}
+
+
+// 语句生成
+void IRGenerator::genStmt(ASTNode* n) {
+    if (!n) return;
+    recordLoc(n->loc);
+    // 保存进入此函数时的作用域，以便在退出时恢复
+    auto originalScope = currentScope_;
+    bool scopePushed = false; // 标记此调用是否改变了作用域
+    switch (n->tag) {
+        case ASTTag::INIT_DECL: {
+            ASTNode* dtor = n->kids[0];
+            std::string varName = extractNameFromDeclarator(dtor); // 使用辅助函数
+            SourceLoc varLoc = dtor ? dtor->loc : n->loc; // 获取位置信息
+
+            if (varName.empty()) {
+                std::cerr << "IR Gen Error: Could not extract variable name in INIT_DECL at line " << n->loc.line << std::endl;
+                break;
+            }
+
+            if (n->kids.size() == 2 && n->kids[1]) { // Has initializer
+                std::string rhs = genExpr(n->kids[1]);
+                Symbol* sym = nullptr;
+                std::cerr << "[DEBUG IRGen] Looking up '" << varName << "' in scope: " << currentScope_.get() << std::endl;
+                if (currentScope_) { // 查找当前作用域
+                    sym = currentScope_->lookup(varName);
+
+                }
+                TypePtr vtype = sym ? sym->type : nullptr;
+
+                if (sym) {
+                    // 找到了符号，现在检查它的类型指针
+                    vtype = sym->type; // 从找到的符号获取类型指针
+                    std::cerr << "[DEBUG IRGen]   Symbol '" << varName << "' FOUND in scope " << currentScope_.get() << ".";
+                    if (vtype) {
+                        // 类型指针有效！
+                        std::cerr << " Type pointer is VALID: " << vtype.get() << " (" << vtype->toString() << ")" << std::endl;
+                    } else {
+                        // 类型指针是 NULL！这就是问题所在
+                        std::cerr << " Type pointer is NULL!" << std::endl;
+                    }
+                } else {
+                    // 符号本身就没找到
+                    std::cerr << "[DEBUG IRGen]   Symbol '" << varName << "' NOT FOUND in scope " << currentScope_.get() << "." << std::endl;
+                }
+
+                if (!vtype) {
+                    // 替换 error 调用
+                    std::cerr << "IR Gen Warning: Could not find symbol type for '" << varName << "' during INIT_DECL at line " << varLoc.line << ". Type info might be missing." << std::endl;
+                    // 尝试从 rhs 推断（如果 rhs 是临时变量且类型已知）
+                    if(tempTypes_.count(rhs)) vtype = tempTypes_[rhs];
+                    // 否则 vtype 保持 nullptr
+                }
+                // 使用变量声明的位置
+                emit("=", rhs, "", varName, varLoc, varName, vtype);
+            }
+            // No IR needed for declaration without initializer in this phase
+            break;
+        }
+
+        case ASTTag::EXPR_STMT:
+            if (!n->kids.empty()) genExpr(n->kids[0]);
+            break;
+
+        case ASTTag::COMPOUND_STMT: {
+            // *** 进入块作用域 ***
+            if (!originalScope) { // 检查原始作用域是否有效
+                std::cerr << "IR Gen Error: Attempting to push scope from a null originalScope at line " << n->loc.line << std::endl;
+                // 在这里应该中断处理，例如 break 或 return
+                break;
+            }
+            currentScope_ = originalScope->push();
+
+            if (!currentScope_) { // 检查 push 操作的结果
+                std::cerr << "IR Gen Error: Pushing scope resulted in nullptr at line " << n->loc.line << std::endl;
+                // push 失败通常是因为原始 Scope 对象不是由 shared_ptr 管理的，
+                // 但我们的 Scope 继承自 enable_shared_from_this，理论上不应失败除非 originalScope 本身有问题。
+                // 或者 originalScope->push() 内部实现有错误。
+                // 中断处理
+                scopePushed = false; // 标记作用域并未成功改变
+                break;
+            }
+            scopePushed = true;
+            // 处理块内各项
+            for (auto* item : n->kids) { // 假设 kids[0] 是 BLOCK_ITEM_LIST
+                genStmt(item);
+            }
+            // 离开作用域的操作将在函数末尾统一处理
+            break;
+        }
+        case ASTTag::BLOCK_ITEM_LIST:
+            for (auto* c : n->kids) genStmt(c);
+            break;
+
+        case ASTTag::BLOCK_STMT:
+            genStmt(n->kids[0]);
+            break;
+
+        case ASTTag::IF_STMT: {
+            std::string L_false = newLabel();
+            std::string L_end   = newLabel();
+
+            std::string cond = genExpr(n->kids[0]);
+            emit("ifFalse", cond, "", L_false, lastLoc_);
+
+            genStmt(n->kids[1]);
+            if (n->kids.size() == 3) {
+                emit("goto", "", "", L_end, lastLoc_);
+                emit("label", "", "", L_false, lastLoc_);
+                genStmt(n->kids[2]);
+                emit("label", "", "", L_end, lastLoc_);
+            } else {
+                emit("label", "", "", L_false, lastLoc_);
+            }
+            break;
+        }
+
+        case ASTTag::WHILE_STMT: {
+            std::string L_top   = newLabel();
+            std::string L_false = newLabel();
+            emit("label", "", "", L_top, lastLoc_);
+
+            std::string cond = genExpr(n->kids[0]);
+            emit("ifFalse", cond, "", L_false, lastLoc_);
+
+            breakLabels_.push_back(L_false);
+            continueLabels_.push_back(L_top);
+
+            genStmt(n->kids[1]);
+            emit("goto", "", "", L_top, lastLoc_);
+            emit("label", "", "", L_false, lastLoc_);
+
+            breakLabels_.pop_back();
+            continueLabels_.pop_back();
+            break;
+        }
+
+        case ASTTag::DO_WHILE_STMT: {
+            std::string L_top   = newLabel();
+            std::string L_false = newLabel();
+            emit("label", "", "", L_top, lastLoc_);
+
+            breakLabels_.push_back(L_false);
+            continueLabels_.push_back(L_top);
+
+            genStmt(n->kids[0]);
+            std::string cond = genExpr(n->kids[1]);
+            emit("ifTrue", cond, "", L_top, lastLoc_);
+
+            emit("label", "", "", L_false, lastLoc_);
+
+            breakLabels_.pop_back();
+            continueLabels_.pop_back();
+            break;
+        }
+
+        case ASTTag::FOR_STMT: {
+            genStmt(n->kids[0]);  // init
+
+            std::string L_top   = newLabel();
+            std::string L_false = newLabel();
+            emit("label", "", "", L_top, lastLoc_);
+
+            if (!n->kids[1]->kids.empty()) {
+                std::string cond = genExpr(n->kids[1]->kids[0]);
+                emit("ifFalse", cond, "", L_false, lastLoc_);
+            }
+
+            breakLabels_.push_back(L_false);
+            continueLabels_.push_back(L_top);
+
+            genStmt(n->kids[3]);         // body
+            if (n->kids[2]) genExpr(n->kids[2]);  // iter
+
+            emit("goto", "", "", L_top, lastLoc_);
+            emit("label", "", "", L_false, lastLoc_);
+
+            breakLabels_.pop_back();
+            continueLabels_.pop_back();
+            break;
+        }
+
+        case ASTTag::BREAK_STMT:
+            assert(!breakLabels_.empty());
+            emit("goto", "", "", breakLabels_.back(), lastLoc_);
+            break;
+
+        case ASTTag::CONTINUE_STMT:
+            assert(!continueLabels_.empty());
+            emit("goto", "", "", continueLabels_.back(), lastLoc_);
+            break;
+
+        case ASTTag::GOTO_STMT:
+            emit("goto", "", "", n->text, lastLoc_);
+            break;
+
+        case ASTTag::LABELED_ID_STMT:
+            emit("label", "", "", n->text, lastLoc_);
+            genStmt(n->kids[0]);
+            break;
+
+        case ASTTag::SWITCH_STMT:
+            genExpr(n->kids[0]);
+            for (auto* c : n->kids[1]->kids)
+                genStmt(c);
+            break;
+
+        case ASTTag::CASE_STMT:
+            genExpr(n->kids[0]);
+            genStmt(n->kids[1]);
+            break;
+
+        case ASTTag::DEFAULT_STMT:
+            genStmt(n->kids[0]);
+            break;
+
+        case ASTTag::RETURN_STMT: {
+            std::string v = n->kids.empty() ? "" : genExpr(n->kids[0]);
+            // 单参 emit("return", ...) 会默认带上 lastLoc_
+            emit("return", v);
+            break;
+        }
+
+
+
+        case ASTTag::FOR_DECL_STMT: {
+            // *** 进入 for 循环作用域 ***
+            if (!originalScope) { // 检查原始作用域是否有效
+                std::cerr << "IR Gen Error: Attempting to push scope from a null originalScope at line " << n->loc.line << std::endl;
+                // 在这里应该中断处理，例如 break 或 return
+                break;
+            }
+            currentScope_ = originalScope->push();
+            scopePushed = true;
+            if (!currentScope_) { // 检查 push 操作的结果
+                std::cerr << "IR Gen Error: Pushing scope resulted in nullptr at line " << n->loc.line << std::endl;
+                // push 失败通常是因为原始 Scope 对象不是由 shared_ptr 管理的，
+                // 但我们的 Scope 继承自 enable_shared_from_this，理论上不应失败除非 originalScope 本身有问题。
+                // 或者 originalScope->push() 内部实现有错误。
+                // 中断处理
+                scopePushed = false; // 标记作用域并未成功改变
+                break;
+            }
+            // 处理初始化声明 (现在在新的 currentScope_ 下)
+            genStmt(n->kids[0]);
+
+            std::string L_top   = newLabel();
+            std::string L_cont  = newLabel(); // Continue 跳转目标
+            std::string L_false = newLabel(); // Break 跳转目标
+
+            emit("label", "", "", L_top, lastLoc_); // 条件检查点
+
+            // 处理条件 (在循环作用域内)
+            if (n->kids[1] && n->kids[1]->tag == ASTTag::EXPR_STMT && !n->kids[1]->kids.empty()) {
+                std::string cond = genExpr(n->kids[1]->kids[0]);
+                emit("ifFalse", cond, "", L_false, lastLoc_);
+            } // 如果没有条件，则无限循环 (除非内部 break)
+
+            breakLabels_.push_back(L_false);
+            continueLabels_.push_back(L_cont);
+
+            // 处理循环体 (在循环作用域内)
+            if (n->kids.size() > 3 && n->kids[3]) genStmt(n->kids[3]);
+
+            emit("label", "", "", L_cont, lastLoc_); // continue 跳转到这里
+            // 处理迭代 (在循环作用域内)
+            if (n->kids.size() > 2 && n->kids[2]) {
+                genExpr(n->kids[2]);
+            }
+
+            emit("goto", "", "", L_top, lastLoc_); // 跳回条件检查
+            emit("label", "", "", L_false, lastLoc_); // break 跳到这里
+
+            breakLabels_.pop_back();
+            continueLabels_.pop_back();
+
+            // 离开作用域的操作将在函数末尾统一处理
+            break;
+        }
+
+        case ASTTag::FUNCTION_DEF: {
+            ASTNode* spec_list = n->kids[0]; // 基本不再需要，类型来自符号表
+            ASTNode* dtor      = n->kids[1];
+            ASTNode* body      = nullptr;
+            if (n->kids.size() > 3 && n->kids[3] && n->kids[3]->tag == ASTTag::COMPOUND_STMT) body = n->kids[3];
+            else if (n->kids.size() > 2 && n->kids[2] && n->kids[2]->tag == ASTTag::COMPOUND_STMT) body = n->kids[2];
+
+            // --- 1. Extract Function Name ---
+            std::string funcName = extractNameFromDeclarator(dtor); // 使用辅助函数
+            SourceLoc nameLoc = dtor ? dtor->loc : n->loc;
+
+            if (funcName.empty()) {
+                 std::cerr << "IR Gen Error: Could not extract function name from FUNCTION_DEF at line " << n->loc.line << std::endl;
+                 funcName = "unknown_function";
+            }
+
+            // --- 2. Get Function Type from Symbol Table ---
+            TypePtr funcType = nullptr;
+            Symbol* funcSymbol = nullptr;
+            if (funcName != "unknown_function" && symbolTable_) { // 使用全局 symbolTable_ 查找
+                funcSymbol = symbolTable_->lookup(funcName);
+            }
+            if (funcSymbol && funcSymbol->type && dynamic_cast<FunctionType*>(funcSymbol->type.get())) {
+                funcType = funcSymbol->type;
+            } else if (funcName != "unknown_function") {
+                 // 替换 error 调用
+                 std::cerr << "IR Gen Error: Could not find symbol or valid type for function '" << funcName << "' in symbol table at line " << nameLoc.line << std::endl;
+            }
+
+            // --- 3. Emit Label ---
+            emit("label", "", "", funcName, n->loc, /*var=*/"", funcType);
+
+            // --- 4. Enter Function Scope ---
+            if (!originalScope) { // 检查原始作用域是否有效
+                std::cerr << "IR Gen Error: Attempting to push scope from a null originalScope at line " << n->loc.line << std::endl;
+                // 在这里应该中断处理，例如 break 或 return
+                break;
+            }
+            currentScope_ = originalScope->push();
+            if (!currentScope_) { // 检查 push 操作的结果
+                std::cerr << "IR Gen Error: Pushing scope resulted in nullptr at line " << n->loc.line << std::endl;
+                // push 失败通常是因为原始 Scope 对象不是由 shared_ptr 管理的，
+                // 但我们的 Scope 继承自 enable_shared_from_this，理论上不应失败除非 originalScope 本身有问题。
+                // 或者 originalScope->push() 内部实现有错误。
+                // 中断处理
+                scopePushed = false; // 标记作用域并未成功改变
+                break;
+            }
+            scopePushed = true;
+
+            // --- 5. Process Parameters (不需要 buildType) ---
+            // IR 生成阶段假设参数已由 SemanticAnalyzer 添加到符号表。
+            // 这里不需要重新插入或构建类型，只需确保后续代码在正确的 scope 中执行。
+            // 如果需要为参数生成特定 IR（如 'arg_alloc'），可以在此处理。
+            // （省略了之前添加参数到 currentScope 的代码，因为这是 SemanticAnalyzer 的职责）
+
+            // --- 6. Generate Function Body ---
+            if (body) {
+                 genStmt(body);
+            } else {
+                 std::cerr << "IR Gen Warning: Function '" << funcName << "' has no body at line " << n->loc.line << std::endl;
+            }
+
+            break; // FUNCTION_DEF handled
+        }
+
+        default:
+            for (auto* c : n->kids)
+                genStmt(c);
+            break;
+    }
+    if (scopePushed) {
+        if (currentScope_) { // 添加检查，防止对空指针调用 pop
+            currentScope_ = currentScope_->pop(); // 正确：恢复到父作用域
+            if (!currentScope_) {
+                // 这个情况通常不应该发生，除非我们弹出了最外层的全局作用域
+                std::cerr << "IR Gen Error: Popped scope resulted in nullptr! (Likely popped global scope or scope management issue)" << std::endl;
+                // 在这里可能需要抛出异常或采取其他错误处理措施
+            }
+        } else {
+            // 如果 scopePushed 为 true 但 currentScope_ 已经是 nullptr，说明状态已损坏
+            std::cerr << "IR Gen Error: Scope stack corrupted before pop attempt." << std::endl;
+        }
+    }
+
+}
+
diff --git a/ir.h b/ir.h
new file mode 100644
index 0000000..58238d1
--- /dev/null
+++ b/ir.h
@@ -0,0 +1,130 @@
+#ifndef MINI_C_IR_H
+#define MINI_C_IR_H
+
+#include <iostream>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include "symbol.h"
+#include "ast.h"
+#include "type.h"
+
+struct Quad {
+    std::string op;      // 操作码，如 "+", "=", "ifFalse", "param", "call", "label", "goto" 等
+    std::string arg1;    // 第一个操作数
+    std::string arg2;    // 第二个操作数（如有）
+    std::string result;  // 结果或目标临时变量、标签名
+    SourceLoc  loc;      // 位置
+    std::string var;     // 如果这是对某个源变量的操作，就记录它的名字
+    TypePtr     type;    // 这条指令结果或变量的类型
+};
+
+class IRGenerator {
+public:
+// 在 ir.cpp 中替换 IRGenerator 构造函数
+
+IRGenerator(std::shared_ptr<Scope> globalScope)
+    // 在初始化列表中先打印 globalScope 的状态
+    : tempCount_(0), labelCount_(0), lastLoc_({0,0}),
+      symbolTable_(
+          // 使用 lambda 在移动前打印 globalScope 状态
+          [&]() -> std::shared_ptr<Scope> {
+              std::cerr << "[DEBUG] IRGenerator Constructor: Initializing symbolTable_..." << std::endl;
+              std::cerr << "[DEBUG]   Input globalScope valid? " << (globalScope ? "Yes" : "No") << std::endl;
+              if(globalScope) std::cerr << "[DEBUG]   Input globalScope points to: " << globalScope.get() << std::endl;
+              return std::move(globalScope); // 执行移动
+          }() // 立即调用 lambda
+      ),
+      currentScope_(
+          // 使用 lambda 在复制前打印 symbolTable_ 状态
+          [&]() -> std::shared_ptr<Scope> {
+              std::cerr << "[DEBUG] IRGenerator Constructor: Initializing currentScope_..." << std::endl;
+              std::cerr << "[DEBUG]   symbolTable_ (after move) valid? " << (symbolTable_ ? "Yes" : "No") << std::endl;
+              if(symbolTable_) std::cerr << "[DEBUG]   symbolTable_ points to: " << symbolTable_.get() << std::endl;
+              return symbolTable_; // 执行复制
+          }() // 立即调用 lambda
+      ),
+      tmpIdx_(0), labelIdx_(0)
+{
+    // 构造函数体内的检查
+    std::cerr << "[DEBUG] IRGenerator Constructor Body Entry." << std::endl;
+
+    // 检查 symbolTable_
+    if (!symbolTable_) {
+         std::cerr << "FATAL ERROR in IRGenerator Constructor Body: symbolTable_ is null!" << std::endl;
+         throw std::runtime_error("IRGenerator requires a valid global scope (symbolTable_ check failed).");
+    } else {
+         std::cerr << "[DEBUG] IRGenerator Constructor Body: symbolTable_ check passed (points to: " << symbolTable_.get() << ")." << std::endl;
+    }
+
+    // 检查 currentScope_ (这是之前出错的地方)
+    if (!currentScope_) {
+         std::cerr << "FATAL ERROR in IRGenerator Constructor Body: currentScope_ is null!" << std::endl;
+         std::cerr << "[DEBUG]   Value of symbolTable_.get() at this point: " << symbolTable_.get() << std::endl; // 再次打印 symbolTable_ 指针
+         throw std::runtime_error("IRGenerator scope initialization failed (currentScope_ check failed).");
+    } else {
+         std::cerr << "[DEBUG] IRGenerator Constructor Body: currentScope_ check passed (points to: " << currentScope_.get() << ")." << std::endl;
+    }
+     std::cerr << "[DEBUG] IRGenerator Constructor Body Exit." << std::endl;
+}
+    std::shared_ptr<Scope> symbolTable_;
+    std::shared_ptr<Scope> currentScope_;
+    // 生成入口
+    std::vector<Quad> generate(ASTNode* root);
+    void recordLoc(SourceLoc loc);
+
+    int tempCount_ = 0;
+    int labelCount_ = 0;
+    std::vector<Quad> quads_;
+    std::vector<std::string> breakLabels_;
+    std::vector<std::string> continueLabels_;
+
+    SourceLoc lastLoc_;                    // 记录上一次要用的位置信息
+    std::unordered_map<std::string,TypePtr> tempTypes_; // 临时变量类型映射
+    int tmpIdx_ = 0, labelIdx_ = 0;
+
+    // 产生新的临时变量名 t1, t2, …
+    std::string newTemp() {
+        return "t" + std::to_string(++tempCount_);
+    }
+    // 产生新的标签名 L1, L2, …
+    std::string newLabel() {
+        return "L" + std::to_string(++labelCount_);
+    }
+    //——— 新版 emit，将类型一起记录 —————————————————————————
+    void emit(const std::string &op,
+                           const std::string &arg1,
+                           const std::string &arg2,
+                           const std::string &res,
+                           SourceLoc loc,
+                           const std::string &var,
+                           TypePtr type) {
+        quads_.push_back({op, arg1, arg2, res, loc, var, type});
+    }
+
+    //——— 兼容旧调用的重载，默认 var = ""，type = nullptr —————————————
+    void emit(const std::string &op,
+                           const std::string &arg1,
+                           const std::string &arg2,
+                           const std::string &res) {
+        emit(op, arg1, arg2, res, lastLoc_, /*var=*/"", /*type=*/nullptr);
+    }
+    void emit(const std::string &op,
+                           const std::string &arg1,
+                           const std::string &arg2,
+                           const std::string &res,
+                           SourceLoc loc) {
+        emit(op, arg1, arg2, res, loc, /*var=*/"", /*type=*/nullptr);
+    }
+    void emit(const std::string &op,
+                           const std::string &arg1) {
+        emit(op, arg1, /*arg2=*/"", /*res=*/"", lastLoc_, /*var=*/"", /*type=*/nullptr);
+    }
+
+    // 递归生成表达式，返回这个表达式的结果临时变量或直接变量名
+    std::string genExpr(ASTNode* n);
+    // 递归生成语句
+    void genStmt(ASTNode* n);
+};
+
+#endif // MINI_C_IR_H
diff --git a/lex.yy.cpp b/lex.yy.cpp
new file mode 100644
index 0000000..8edf8b5
--- /dev/null
+++ b/lex.yy.cpp
@@ -0,0 +1,2599 @@
+#line 1 "lex.yy.cpp"
+
+#line 3 "lex.yy.cpp"
+
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types. 
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t; 
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX               (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an
+ *   integer in range [0..255] for use as an array index.
+ */
+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN (yy_start) = 1 + 2 *
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START (((yy_start) - 1) / 2)
+#define YYSTATE YY_START
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin  )
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+extern int yyleng;
+
+extern FILE *yyin, *yyout;
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+    
+    /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
+     *       access to the local variable yy_act. Since yyless() is a macro, it would break
+     *       existing scanners that call yyless() from OUTSIDE yylex.
+     *       One obvious solution it to make yy_act a global. I tried that, and saw
+     *       a 5% performance hit in a non-yylineno scanner, because yy_act is
+     *       normally declared as a register variable-- so it is not worth it.
+     */
+    #define  YY_LESS_LINENO(n) \
+            do { \
+                int yyl;\
+                for ( yyl = n; yyl < yyleng; ++yyl )\
+                    if ( yytext[yyl] == '\n' )\
+                        --yylineno;\
+            }while(0)
+    #define YY_LINENO_REWIND_TO(dst) \
+            do {\
+                const char *p;\
+                for ( p = yy_cp-1; p >= (dst); --p)\
+                    if ( *p == '\n' )\
+                        --yylineno;\
+            }while(0)
+    
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		*yy_cp = (yy_hold_char); \
+		YY_RESTORE_YY_MORE_OFFSET \
+		(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+#define unput(c) yyunput( c, (yytext_ptr)  )
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	int yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via yyrestart()), so that the user can continue scanning by
+	 * just pointing yyin at a new input file.
+	 */
+#define YY_BUFFER_EOF_PENDING 2
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* Stack of input buffers. */
+static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
+static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
+static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
+ */
+#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
+                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
+                          : NULL)
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
+
+/* yy_hold_char holds the character lost when yytext is formed. */
+static char yy_hold_char;
+static int yy_n_chars;		/* number of characters read into yy_ch_buf */
+int yyleng;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = NULL;
+static int yy_init = 0;		/* whether we need to initialize */
+static int yy_start = 0;	/* start state number */
+
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+void yyrestart ( FILE *input_file  );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer  );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size  );
+void yy_delete_buffer ( YY_BUFFER_STATE b  );
+void yy_flush_buffer ( YY_BUFFER_STATE b  );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer  );
+void yypop_buffer_state ( void );
+
+static void yyensure_buffer_stack ( void );
+static void yy_load_buffer_state ( void );
+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file  );
+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size  );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str  );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len  );
+
+void *yyalloc ( yy_size_t  );
+void *yyrealloc ( void *, yy_size_t  );
+void yyfree ( void *  );
+
+#define yy_new_buffer yy_create_buffer
+#define yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){ \
+        yyensure_buffer_stack (); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE ); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+	}
+#define yy_set_bol(at_bol) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){\
+        yyensure_buffer_stack (); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE ); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+	}
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
+typedef flex_uint8_t YY_CHAR;
+
+FILE *yyin = NULL, *yyout = NULL;
+
+typedef int yy_state_type;
+
+extern int yylineno;
+int yylineno = 1;
+
+extern char *yytext;
+#ifdef yytext_ptr
+#undef yytext_ptr
+#endif
+#define yytext_ptr yytext
+
+static yy_state_type yy_get_previous_state ( void );
+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  );
+static int yy_get_next_buffer ( void );
+static void yynoreturn yy_fatal_error ( const char* msg  );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+	(yytext_ptr) = yy_bp; \
+	yyleng = (int) (yy_cp - yy_bp); \
+	(yy_hold_char) = *yy_cp; \
+	*yy_cp = '\0'; \
+	(yy_c_buf_p) = yy_cp;
+#define YY_NUM_RULES 99
+#define YY_END_OF_BUFFER 100
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+	{
+	flex_int32_t yy_verify;
+	flex_int32_t yy_nxt;
+	};
+static const flex_int16_t yy_accept[316] =
+    {   0,
+        0,    0,  100,   98,   97,   97,   85,   98,   91,   84,
+       98,   79,   80,   89,   88,   76,   87,   83,   90,   41,
+       42,   77,   73,   92,   78,   93,   96,   39,   39,   81,
+       82,   94,   39,   39,   39,   39,   39,   39,   39,   39,
+       39,   39,   39,   39,   39,   39,   39,   39,   39,   74,
+       95,   75,   86,   72,    0,   50,    0,   58,   75,   67,
+       59,    0,    0,   56,   64,   54,   65,   55,   66,    0,
+       45,    1,   57,   46,   41,    0,    0,   41,   41,    0,
+       41,   42,   42,   42,   42,   82,   74,   81,   63,   69,
+       71,   70,   62,   39,    0,    0,   60,   39,   39,   39,
+
+       39,   39,   39,   39,   39,   39,   11,   39,   39,   39,
+       39,   39,   39,   19,   39,   39,   39,   39,   39,   39,
+       39,   39,   39,   39,   39,   61,   68,   43,   51,    0,
+       45,   45,    0,   46,    0,   44,   41,   41,   41,   41,
+        0,   40,   42,   42,   42,   42,   53,   52,   39,   39,
+       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
+       39,   39,   17,   39,   39,   22,   39,   39,   39,   39,
+       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
+       39,   39,    0,   45,    0,   45,    0,   46,   44,   41,
+       48,   49,   40,    0,   40,   40,   42,   39,   39,   39,
+
+        2,   39,    5,    6,   39,   39,   39,   39,   13,   14,
+       39,   39,   18,   39,   23,   39,   39,   39,   39,   39,
+       39,   39,   39,   39,   39,   39,   39,   36,   39,   39,
+        0,   45,   48,    0,   48,   49,    0,   40,   40,    0,
+       47,   40,   40,    3,   39,   39,    4,    8,   39,   39,
+       39,   39,   16,   39,   39,   39,   39,   27,   39,   39,
+       39,   39,   39,   39,   34,   39,   39,   38,    0,   48,
+       48,    0,    0,   49,   47,   40,   39,   39,   39,   39,
+       12,   15,   21,   39,   39,   26,   28,   29,   30,   31,
+       32,   39,   39,   39,    0,   48,   39,   39,   39,   10,
+
+       39,   39,   33,   39,   39,    7,   39,    9,   24,   25,
+       35,   37,   39,   20,    0
+    } ;
+
+static const YY_CHAR yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        2,    2,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    4,    5,    1,    1,    6,    7,    8,    9,
+       10,   11,   12,   13,   14,   15,   16,   17,   18,   18,
+       18,   18,   18,   18,   18,   19,   19,   20,   21,   22,
+       23,   24,   25,    1,   26,   27,   28,   26,   29,   30,
+       31,   31,   32,   31,   31,   33,   31,   31,   31,   34,
+       31,   31,   31,   31,   35,   31,   31,   36,   31,   31,
+       37,   38,   39,   40,   41,    1,   42,   43,   44,   45,
+
+       46,   47,   48,   49,   50,   31,   51,   52,   53,   54,
+       55,   56,   31,   57,   58,   59,   60,   61,   62,   63,
+       64,   65,   66,   67,   68,   69,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static const YY_CHAR yy_meta[70] =
+    {   0,
+        1,    1,    2,    1,    1,    1,    1,    3,    1,    1,
+        1,    1,    1,    1,    4,    1,    5,    5,    5,    1,
+        1,    1,    1,    1,    1,    5,    5,    5,    5,    5,
+        6,    6,    7,    7,    6,    6,    1,    1,    1,    1,
+        6,    5,    5,    5,    5,    5,    5,    6,    6,    6,
+        6,    7,    6,    6,    6,    7,    6,    6,    6,    6,
+        6,    6,    6,    6,    6,    1,    1,    1,    1
+    } ;
+
+static const flex_int16_t yy_base[322] =
+    {   0,
+        0,    0,  540,  541,  541,  541,  516,   65,   48,   66,
+      500,  541,  541,  514,   62,  541,   63,   61,   70,   89,
+       80,  512,  541,   94,  512,   59,  541,    0,   83,  541,
+      541,  511,  101,  473,  475,   81,   29,   38,   50,  476,
+       65,  475,    0,  483,   88,  464,  473,  471,  476,  541,
+       87,  541,  541,  541,   89,  541,    0,  541,  541,  541,
+      541,  113,  516,  541,  541,  541,  541,  541,  541,  508,
+      126,  541,  541,  146,  151,  170,  188,  148,   87,  507,
+      122,  195,  161,  101,  166,  541,  541,  541,  498,  541,
+      541,  541,  497,    0,  153,  481,  541,  463,  462,  463,
+
+      456,  468,  455,  470,  457,  463,  449,  450,  447,  447,
+      450,  447,  444,    0,  108,  448,  161,  446,   83,   54,
+      450,  443,  165,  175,  448,  541,  541,  541,  541,  217,
+      541,  220,  240,  541,  225,  243,  111,  541,  464,  444,
+        0,  236,  205,  541,  462,  442,  541,  541,  438,  439,
+      449,  435,  447,  442,  430,  103,  444,  442,  438,  430,
+      436,  439,    0,  425,  429,    0,  430,  427,  417,  415,
+      417,  419,  426,  411,  399,  399,  405,  393,  397,  401,
+      403,  391,  260,  264,  286,  541,  267,  289,  541,  541,
+      212,  268,  254,  309,  223,  239,  541,  390,  385,  392,
+
+        0,  388,    0,    0,  379,  387,  376,  383,    0,    0,
+      377,  374,    0,  378,    0,  371,  371,  368,  365,  377,
+      367,  371,  376,  375,  373,  363,  365,    0,  351,  362,
+      312,  315,  541,  325,  313,  541,  337,  258,  541,  340,
+      353,  374,  352,    0,  347,  341,    0,    0,  333,  333,
+      338,  328,    0,  322,  307,  314,  309,    0,  316,  313,
+      309,  293,  301,  294,    0,  284,  285,    0,  356,  359,
+      541,  376,  362,  379,  541,  541,  279,  263,  255,  254,
+        0,    0,    0,  266,  266,    0,    0,    0,    0,    0,
+        0,  262,  234,  211,  384,  397,  185,  191,  186,    0,
+
+      165,  158,    0,  159,  149,    0,  133,    0,    0,    0,
+        0,    0,  113,    0,  541,  449,  456,  459,  463,  137,
+      464
+    } ;
+
+static const flex_int16_t yy_def[322] =
+    {   0,
+      315,    1,  315,  315,  315,  315,  315,  316,  315,  315,
+      317,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+      315,  315,  315,  315,  315,  315,  315,  318,  318,  315,
+      315,  315,  318,  318,  318,  318,  318,  318,  318,  318,
+      318,  318,  318,  318,  318,  318,  318,  318,  318,  315,
+      315,  315,  315,  315,  316,  315,  316,  315,  315,  315,
+      315,  317,  317,  315,  315,  315,  315,  315,  315,  315,
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  319,
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+      315,  315,  315,  318,  316,  317,  315,  318,  318,  318,
+
+      318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+      318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+      318,  318,  318,  318,  318,  315,  315,  315,  315,  315,
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+      320,  319,  315,  315,  315,  315,  315,  315,  318,  318,
+      318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+      318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+      318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+      318,  318,  315,  315,  315,  315,  315,  315,  315,  315,
+      320,  321,  315,  315,  315,  315,  315,  318,  318,  318,
+
+      318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+      318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+      318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+      315,  315,  315,  315,  321,  315,  315,  315,  315,  315,
+      315,  315,  315,  318,  318,  318,  318,  318,  318,  318,
+      318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+      318,  318,  318,  318,  318,  318,  318,  318,  315,  315,
+      315,  315,  315,  315,  315,  315,  318,  318,  318,  318,
+      318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+      318,  318,  318,  318,  315,  315,  318,  318,  318,  318,
+
+      318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+      318,  318,  318,  318,    0,  315,  315,  315,  315,  315,
+      315
+    } ;
+
+static const flex_int16_t yy_nxt[611] =
+    {   0,
+        4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
+       14,   15,   16,   17,   18,   19,   20,   21,   21,   22,
+       23,   24,   25,   26,   27,   28,   28,   28,   28,   28,
+       28,   28,   29,   28,   28,   28,   30,    4,   31,   32,
+       33,   34,   35,   36,   37,   38,   39,   40,   28,   41,
+       28,   42,   28,   28,   28,   43,   44,   45,   46,   47,
+       48,   49,   28,   28,   28,   50,   51,   52,   53,   56,
+       58,   59,   60,   65,  106,   70,   67,   71,   71,   71,
+       72,   92,   93,  107,   66,   68,   69,   95,   61,  108,
+       96,  109,   73,   56,   74,  174,   82,   82,   82,   87,
+
+      110,  111,   57,   74,  112,   75,   75,   76,   77,  126,
+      175,  114,   83,   88,   84,   89,   90,   77,  115,  139,
+      128,   78,  103,   79,   80,   77,   57,   98,   99,  104,
+      172,   85,  100,  145,   77,  105,  118,  119,  140,   84,
+       81,  191,   71,   71,   71,  138,  120,  173,   79,  121,
+       63,   80,  146,  127,  130,  131,  138,   56,  131,  165,
+      205,  206,  132,  132,  132,   74,  166,   75,   75,   76,
+      138,  130,  131,  137,  133,  134,  314,  131,  134,   77,
+      137,  138,  138,   78,   74,   79,   76,   76,   76,  313,
+       57,  133,  134,  143,  312,  144,   77,  134,   77,  135,
+
+      144,  135,   81,  311,  136,  136,  136,  138,  168,   74,
+       79,   82,   82,   82,  178,   77,  310,  143,  169,  170,
+      144,  309,  179,   77,  180,  144,  181,   83,  183,   84,
+      183,  308,  307,  184,  184,  184,  132,  132,  132,  144,
+       77,  136,  136,  136,  233,  234,   85,  306,  185,  186,
+      192,  187,  186,  187,   84,  242,  188,  188,  188,  136,
+      136,  136,  305,  233,  144,  185,  186,  234,  193,  194,
+      195,  186,  189,  239,  243,  189,  184,  184,  184,  304,
+      184,  184,  184,  188,  188,  188,  238,  196,  239,  189,
+      238,  194,  239,  131,  189,  195,  131,  231,  239,  231,
+
+      236,  237,  232,  232,  232,  188,  188,  188,  303,  302,
+      131,  301,  300,  239,  299,  131,  298,  239,  134,  236,
+      240,  134,  240,  237,  297,  241,  241,  241,  232,  232,
+      232,  232,  232,  232,  294,  134,  269,  293,  269,  292,
+      134,  270,  270,  270,  186,  271,  272,  186,  273,  291,
+      273,  290,  289,  274,  274,  274,  241,  241,  241,  288,
+      287,  186,  286,  285,  271,  284,  186,  283,  272,  241,
+      241,  241,  270,  270,  270,  270,  270,  270,  274,  274,
+      274,  282,  275,  281,  280,  275,  279,  295,  233,  295,
+      278,  233,  296,  296,  296,  274,  274,  274,  277,  275,
+
+      296,  296,  296,  276,  275,  233,  276,  268,  236,  267,
+      233,  236,  266,  296,  296,  296,  265,  264,  263,  262,
+      261,  260,  259,  258,  257,  236,  271,  256,  255,  271,
+      236,  254,  253,  252,  251,  250,  249,  248,  247,  246,
+      245,  244,  230,  271,  229,  228,  227,  226,  271,   55,
+      225,   55,   55,   55,   55,   55,   62,  224,  223,   62,
+       62,   62,   62,   94,   94,   94,  142,  142,  235,  222,
+      235,  221,  220,  219,  218,  217,  216,  215,  214,  213,
+      212,  211,  210,  209,  208,  207,  204,  203,  202,  201,
+      200,  199,  198,  197,  197,  190,  190,  182,  177,  176,
+
+      171,  167,  164,  163,  162,  161,  160,  159,  158,  157,
+      156,  155,  154,  153,  152,  151,  150,  149,   63,  148,
+      147,  141,  129,   62,  125,  124,  123,  122,  117,  116,
+      113,  102,  101,   97,   91,   86,   64,   63,   54,  315,
+        3,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  315
+    } ;
+
+static const flex_int16_t yy_chk[611] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    8,
+        9,    9,   10,   15,   37,   18,   17,   18,   18,   18,
+       19,   26,   26,   37,   15,   17,   17,   29,   10,   38,
+       29,   38,   19,   55,   21,  120,   21,   21,   21,   24,
+
+       38,   39,    8,   20,   39,   20,   20,   20,   21,   51,
+      120,   41,   21,   24,   21,   24,   24,   20,   41,   79,
+       62,   20,   36,   20,   20,   21,   55,   33,   33,   36,
+      119,   21,   33,   84,   20,   36,   45,   45,   79,   21,
+       20,  320,   71,   71,   71,  137,   45,  119,   20,   45,
+       62,   20,   84,   51,   71,   71,   81,   95,   71,  115,
+      156,  156,   74,   74,   74,   75,  115,   75,   75,   75,
+      137,   71,   71,   81,   74,   74,  313,   71,   74,   75,
+       78,   81,   78,   75,   76,   75,   76,   76,   76,  307,
+       95,   74,   74,   83,  305,   83,   75,   74,   76,   77,
+
+       85,   77,   75,  304,   77,   77,   77,   78,  117,   82,
+       75,   82,   82,   82,  123,   76,  302,   85,  117,  117,
+       83,  301,  123,   82,  124,   85,  124,   82,  130,   82,
+      130,  299,  298,  130,  130,  130,  132,  132,  132,  143,
+       82,  135,  135,  135,  191,  191,   82,  297,  132,  132,
+      142,  133,  132,  133,   82,  195,  133,  133,  133,  136,
+      136,  136,  294,  191,  143,  132,  132,  191,  142,  142,
+      142,  132,  136,  196,  195,  136,  183,  183,  183,  293,
+      184,  184,  184,  187,  187,  187,  193,  142,  193,  136,
+      196,  142,  238,  184,  136,  142,  184,  185,  196,  185,
+
+      192,  192,  185,  185,  185,  188,  188,  188,  292,  285,
+      184,  284,  280,  193,  279,  184,  278,  238,  188,  192,
+      194,  188,  194,  192,  277,  194,  194,  194,  231,  231,
+      231,  232,  232,  232,  267,  188,  234,  266,  234,  264,
+      188,  234,  234,  234,  232,  235,  235,  232,  237,  263,
+      237,  262,  261,  237,  237,  237,  240,  240,  240,  260,
+      259,  232,  257,  256,  235,  255,  232,  254,  235,  241,
+      241,  241,  269,  269,  269,  270,  270,  270,  273,  273,
+      273,  252,  241,  251,  250,  241,  249,  272,  270,  272,
+      246,  270,  272,  272,  272,  274,  274,  274,  245,  241,
+
+      295,  295,  295,  243,  241,  270,  242,  230,  274,  229,
+      270,  274,  227,  296,  296,  296,  226,  225,  224,  223,
+      222,  221,  220,  219,  218,  274,  296,  217,  216,  296,
+      274,  214,  212,  211,  208,  207,  206,  205,  202,  200,
+      199,  198,  182,  296,  181,  180,  179,  178,  296,  316,
+      177,  316,  316,  316,  316,  316,  317,  176,  175,  317,
+      317,  317,  317,  318,  318,  318,  319,  319,  321,  174,
+      321,  173,  172,  171,  170,  169,  168,  167,  165,  164,
+      162,  161,  160,  159,  158,  157,  155,  154,  153,  152,
+      151,  150,  149,  146,  145,  140,  139,  125,  122,  121,
+
+      118,  116,  113,  112,  111,  110,  109,  108,  107,  106,
+      105,  104,  103,  102,  101,  100,   99,   98,   96,   93,
+       89,   80,   70,   63,   49,   48,   47,   46,   44,   42,
+       40,   35,   34,   32,   25,   22,   14,   11,    7,    3,
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
+
+      315,  315,  315,  315,  315,  315,  315,  315,  315,  315
+    } ;
+
+/* Table of booleans, true if rule could match eol. */
+static const flex_int32_t yy_rule_can_match_eol[100] =
+    {   0,
+0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 
+        };
+
+static yy_state_type yy_last_accepting_state;
+static char *yy_last_accepting_cpos;
+
+extern int yy_flex_debug;
+int yy_flex_debug = 0;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+char *yytext;
+#line 1 "mini_c.l"
+#line 13 "mini_c.l"
+#include <stdio.h>
+#include <string.h>
+#include "ast.h"
+#include "mini_c.tab.hpp"
+#define SET_SVAL  yylval.sval = strdup(yytext)
+void count(void);
+
+void comment(void);
+
+int column = 0;
+int  check_type(void);
+void error(const char*);   /* 已在 .l 末尾实现 */
+
+extern int yylineno;
+
+#define YY_USER_ACTION                           \
+  yylloc.first_line   = yylineno;                \
+  yylloc.first_column = column;                  \
+  yylloc.last_line    = yylineno;                \
+  yylloc.last_column  = column + yyleng - 1;     \
+  column += yyleng;
+
+
+
+#line 737 "lex.yy.cpp"
+#line 738 "lex.yy.cpp"
+
+#define INITIAL 0
+
+#ifndef YY_NO_UNISTD_H
+/* Special case for "unistd.h", since it is non-ANSI. We include it way
+ * down here because we want the user's section 1 to have been scanned first.
+ * The user has a chance to override it with an option.
+ */
+#include <unistd.h>
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+static int yy_init_globals ( void );
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( void );
+
+int yyget_debug ( void );
+
+void yyset_debug ( int debug_flag  );
+
+YY_EXTRA_TYPE yyget_extra ( void );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined  );
+
+FILE *yyget_in ( void );
+
+void yyset_in  ( FILE * _in_str  );
+
+FILE *yyget_out ( void );
+
+void yyset_out  ( FILE * _out_str  );
+
+			int yyget_leng ( void );
+
+char *yyget_text ( void );
+
+int yyget_lineno ( void );
+
+void yyset_lineno ( int _line_number  );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( void );
+#else
+extern int yywrap ( void );
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+    
+    static void yyunput ( int c, char *buf_ptr  );
+    
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int );
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * );
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput ( void );
+#else
+static int input ( void );
+#endif
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+		{ \
+		int c = '*'; \
+		int n; \
+		for ( n = 0; n < max_size && \
+			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+			buf[n] = (char) c; \
+		if ( c == '\n' ) \
+			buf[n++] = (char) c; \
+		if ( c == EOF && ferror( yyin ) ) \
+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
+		result = n; \
+		} \
+	else \
+		{ \
+		errno=0; \
+		while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
+			{ \
+			if( errno != EINTR) \
+				{ \
+				YY_FATAL_ERROR( "input in flex scanner failed" ); \
+				break; \
+				} \
+			errno=0; \
+			clearerr(yyin); \
+			} \
+		}\
+\
+
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+#endif
+
+/* end tables serialization structures and prototypes */
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (void);
+
+#define YY_DECL int yylex (void)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK /*LINTED*/break;
+#endif
+
+#define YY_RULE_SETUP \
+	YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+	yy_state_type yy_current_state;
+	char *yy_cp, *yy_bp;
+	int yy_act;
+    
+	if ( !(yy_init) )
+		{
+		(yy_init) = 1;
+
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! (yy_start) )
+			(yy_start) = 1;	/* first start state */
+
+		if ( ! yyin )
+			yyin = stdin;
+
+		if ( ! yyout )
+			yyout = stdout;
+
+		if ( ! YY_CURRENT_BUFFER ) {
+			yyensure_buffer_stack ();
+			YY_CURRENT_BUFFER_LVALUE =
+				yy_create_buffer( yyin, YY_BUF_SIZE );
+		}
+
+		yy_load_buffer_state(  );
+		}
+
+	{
+#line 40 "mini_c.l"
+
+#line 957 "lex.yy.cpp"
+
+	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = (yy_c_buf_p);
+
+		/* Support of yytext. */
+		*yy_cp = (yy_hold_char);
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = (yy_start);
+yy_match:
+		do
+			{
+			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+			if ( yy_accept[yy_current_state] )
+				{
+				(yy_last_accepting_state) = yy_current_state;
+				(yy_last_accepting_cpos) = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 316 )
+					yy_c = yy_meta[yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 541 );
+
+yy_find_action:
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = (yy_last_accepting_cpos);
+			yy_current_state = (yy_last_accepting_state);
+			yy_act = yy_accept[yy_current_state];
+			}
+
+		YY_DO_BEFORE_ACTION;
+
+		if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
+			{
+			int yyl;
+			for ( yyl = 0; yyl < yyleng; ++yyl )
+				if ( yytext[yyl] == '\n' )
+					
+    yylineno++;
+;
+			}
+
+do_action:	/* This label is used only to access EOF actions. */
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = (yy_hold_char);
+			yy_cp = (yy_last_accepting_cpos);
+			yy_current_state = (yy_last_accepting_state);
+			goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+#line 41 "mini_c.l"
+{ comment(); }
+	YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 44 "mini_c.l"
+{ count(); return(AUTO); }
+	YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 45 "mini_c.l"
+{ count(); return(BOOL); }
+	YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 46 "mini_c.l"
+{ count(); return(BREAK); }
+	YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 47 "mini_c.l"
+{ count(); return(CASE); }
+	YY_BREAK
+case 6:
+YY_RULE_SETUP
+#line 48 "mini_c.l"
+{ count(); return(CHAR); }
+	YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 49 "mini_c.l"
+{ count(); return(COMPLEX); }
+	YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 50 "mini_c.l"
+{ count(); return(CONST); }
+	YY_BREAK
+case 9:
+YY_RULE_SETUP
+#line 51 "mini_c.l"
+{ count(); return(CONTINUE); }
+	YY_BREAK
+case 10:
+YY_RULE_SETUP
+#line 52 "mini_c.l"
+{ count(); return(DEFAULT); }
+	YY_BREAK
+case 11:
+YY_RULE_SETUP
+#line 53 "mini_c.l"
+{ count(); return(DO); }
+	YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 54 "mini_c.l"
+{ count(); return(DOUBLE); }
+	YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 55 "mini_c.l"
+{ count(); return(ELSE); }
+	YY_BREAK
+case 14:
+YY_RULE_SETUP
+#line 56 "mini_c.l"
+{ count(); return(ENUM); }
+	YY_BREAK
+case 15:
+YY_RULE_SETUP
+#line 57 "mini_c.l"
+{ count(); return(EXTERN); }
+	YY_BREAK
+case 16:
+YY_RULE_SETUP
+#line 58 "mini_c.l"
+{ count(); return(FLOAT); }
+	YY_BREAK
+case 17:
+YY_RULE_SETUP
+#line 59 "mini_c.l"
+{ count(); return(FOR); }
+	YY_BREAK
+case 18:
+YY_RULE_SETUP
+#line 60 "mini_c.l"
+{ count(); return(GOTO); }
+	YY_BREAK
+case 19:
+YY_RULE_SETUP
+#line 61 "mini_c.l"
+{ count(); return(IF); }
+	YY_BREAK
+case 20:
+YY_RULE_SETUP
+#line 62 "mini_c.l"
+{ count(); return(IMAGINARY); }
+	YY_BREAK
+case 21:
+YY_RULE_SETUP
+#line 63 "mini_c.l"
+{ count(); return(INLINE); }
+	YY_BREAK
+case 22:
+YY_RULE_SETUP
+#line 64 "mini_c.l"
+{ count(); return(INT); }
+	YY_BREAK
+case 23:
+YY_RULE_SETUP
+#line 65 "mini_c.l"
+{ count(); return(LONG); }
+	YY_BREAK
+case 24:
+YY_RULE_SETUP
+#line 66 "mini_c.l"
+{ count(); return(REGISTER); }
+	YY_BREAK
+case 25:
+YY_RULE_SETUP
+#line 67 "mini_c.l"
+{ count(); return(RESTRICT); }
+	YY_BREAK
+case 26:
+YY_RULE_SETUP
+#line 68 "mini_c.l"
+{ count(); return(RETURN); }
+	YY_BREAK
+case 27:
+YY_RULE_SETUP
+#line 69 "mini_c.l"
+{ count(); return(SHORT); }
+	YY_BREAK
+case 28:
+YY_RULE_SETUP
+#line 70 "mini_c.l"
+{ count(); return(SIGNED); }
+	YY_BREAK
+case 29:
+YY_RULE_SETUP
+#line 71 "mini_c.l"
+{ count(); return(SIZEOF); }
+	YY_BREAK
+case 30:
+YY_RULE_SETUP
+#line 72 "mini_c.l"
+{ count(); return(STATIC); }
+	YY_BREAK
+case 31:
+YY_RULE_SETUP
+#line 73 "mini_c.l"
+{ count(); return(STRUCT); }
+	YY_BREAK
+case 32:
+YY_RULE_SETUP
+#line 74 "mini_c.l"
+{ count(); return(SWITCH); }
+	YY_BREAK
+case 33:
+YY_RULE_SETUP
+#line 75 "mini_c.l"
+{ count(); return(TYPEDEF); }
+	YY_BREAK
+case 34:
+YY_RULE_SETUP
+#line 76 "mini_c.l"
+{ count(); return(UNION); }
+	YY_BREAK
+case 35:
+YY_RULE_SETUP
+#line 77 "mini_c.l"
+{ count(); return(UNSIGNED); }
+	YY_BREAK
+case 36:
+YY_RULE_SETUP
+#line 78 "mini_c.l"
+{ count(); return(VOID); }
+	YY_BREAK
+case 37:
+YY_RULE_SETUP
+#line 79 "mini_c.l"
+{ count(); return(VOLATILE); }
+	YY_BREAK
+case 38:
+YY_RULE_SETUP
+#line 80 "mini_c.l"
+{ count(); return(WHILE); }
+	YY_BREAK
+case 39:
+YY_RULE_SETUP
+#line 82 "mini_c.l"
+{ count(); SET_SVAL; return(check_type()); }
+	YY_BREAK
+case 40:
+YY_RULE_SETUP
+#line 84 "mini_c.l"
+{ count(); SET_SVAL; return(CONSTANT); }
+	YY_BREAK
+case 41:
+YY_RULE_SETUP
+#line 85 "mini_c.l"
+{ count(); SET_SVAL; return(CONSTANT); }
+	YY_BREAK
+case 42:
+YY_RULE_SETUP
+#line 86 "mini_c.l"
+{ count(); SET_SVAL; return(CONSTANT); }
+	YY_BREAK
+case 43:
+YY_RULE_SETUP
+#line 87 "mini_c.l"
+{ count(); SET_SVAL; return(CONSTANT); }
+	YY_BREAK
+case 44:
+YY_RULE_SETUP
+#line 89 "mini_c.l"
+{ count(); SET_SVAL; return(CONSTANT); }
+	YY_BREAK
+case 45:
+YY_RULE_SETUP
+#line 90 "mini_c.l"
+{ count(); SET_SVAL; return(CONSTANT); }
+	YY_BREAK
+case 46:
+YY_RULE_SETUP
+#line 91 "mini_c.l"
+{ count(); SET_SVAL; return(CONSTANT); }
+	YY_BREAK
+case 47:
+YY_RULE_SETUP
+#line 92 "mini_c.l"
+{ count(); SET_SVAL; return(CONSTANT); }
+	YY_BREAK
+case 48:
+YY_RULE_SETUP
+#line 93 "mini_c.l"
+{ count(); SET_SVAL; return(CONSTANT); }
+	YY_BREAK
+case 49:
+YY_RULE_SETUP
+#line 94 "mini_c.l"
+{ count(); SET_SVAL; return(CONSTANT); }
+	YY_BREAK
+case 50:
+YY_RULE_SETUP
+#line 97 "mini_c.l"
+{ count(); SET_SVAL; return(STRING_LITERAL); }
+	YY_BREAK
+case 51:
+YY_RULE_SETUP
+#line 99 "mini_c.l"
+{ count(); return(ELLIPSIS); }
+	YY_BREAK
+case 52:
+YY_RULE_SETUP
+#line 100 "mini_c.l"
+{ count(); return(RIGHT_ASSIGN); }
+	YY_BREAK
+case 53:
+YY_RULE_SETUP
+#line 101 "mini_c.l"
+{ count(); return(LEFT_ASSIGN); }
+	YY_BREAK
+case 54:
+YY_RULE_SETUP
+#line 102 "mini_c.l"
+{ count(); return(ADD_ASSIGN); }
+	YY_BREAK
+case 55:
+YY_RULE_SETUP
+#line 103 "mini_c.l"
+{ count(); return(SUB_ASSIGN); }
+	YY_BREAK
+case 56:
+YY_RULE_SETUP
+#line 104 "mini_c.l"
+{ count(); return(MUL_ASSIGN); }
+	YY_BREAK
+case 57:
+YY_RULE_SETUP
+#line 105 "mini_c.l"
+{ count(); return(DIV_ASSIGN); }
+	YY_BREAK
+case 58:
+YY_RULE_SETUP
+#line 106 "mini_c.l"
+{ count(); return(MOD_ASSIGN); }
+	YY_BREAK
+case 59:
+YY_RULE_SETUP
+#line 107 "mini_c.l"
+{ count(); return(AND_ASSIGN); }
+	YY_BREAK
+case 60:
+YY_RULE_SETUP
+#line 108 "mini_c.l"
+{ count(); return(XOR_ASSIGN); }
+	YY_BREAK
+case 61:
+YY_RULE_SETUP
+#line 109 "mini_c.l"
+{ count(); return(OR_ASSIGN); }
+	YY_BREAK
+case 62:
+YY_RULE_SETUP
+#line 110 "mini_c.l"
+{ count(); return(RIGHT_OP); }
+	YY_BREAK
+case 63:
+YY_RULE_SETUP
+#line 111 "mini_c.l"
+{ count(); return(LEFT_OP); }
+	YY_BREAK
+case 64:
+YY_RULE_SETUP
+#line 112 "mini_c.l"
+{ count(); return(INC_OP); }
+	YY_BREAK
+case 65:
+YY_RULE_SETUP
+#line 113 "mini_c.l"
+{ count(); return(DEC_OP); }
+	YY_BREAK
+case 66:
+YY_RULE_SETUP
+#line 114 "mini_c.l"
+{ count(); return(PTR_OP); }
+	YY_BREAK
+case 67:
+YY_RULE_SETUP
+#line 115 "mini_c.l"
+{ count(); return(AND_OP); }
+	YY_BREAK
+case 68:
+YY_RULE_SETUP
+#line 116 "mini_c.l"
+{ count(); return(OR_OP); }
+	YY_BREAK
+case 69:
+YY_RULE_SETUP
+#line 117 "mini_c.l"
+{ count(); return(LE_OP); }
+	YY_BREAK
+case 70:
+YY_RULE_SETUP
+#line 118 "mini_c.l"
+{ count(); return(GE_OP); }
+	YY_BREAK
+case 71:
+YY_RULE_SETUP
+#line 119 "mini_c.l"
+{ count(); return(EQ_OP); }
+	YY_BREAK
+case 72:
+YY_RULE_SETUP
+#line 120 "mini_c.l"
+{ count(); return(NE_OP); }
+	YY_BREAK
+case 73:
+YY_RULE_SETUP
+#line 121 "mini_c.l"
+{ count(); return(';'); }
+	YY_BREAK
+case 74:
+YY_RULE_SETUP
+#line 122 "mini_c.l"
+{ count(); return('{'); }
+	YY_BREAK
+case 75:
+YY_RULE_SETUP
+#line 123 "mini_c.l"
+{ count(); return('}'); }
+	YY_BREAK
+case 76:
+YY_RULE_SETUP
+#line 124 "mini_c.l"
+{ count(); return(','); }
+	YY_BREAK
+case 77:
+YY_RULE_SETUP
+#line 125 "mini_c.l"
+{ count(); return(':'); }
+	YY_BREAK
+case 78:
+YY_RULE_SETUP
+#line 126 "mini_c.l"
+{ count(); return('='); }
+	YY_BREAK
+case 79:
+YY_RULE_SETUP
+#line 127 "mini_c.l"
+{ count(); return('('); }
+	YY_BREAK
+case 80:
+YY_RULE_SETUP
+#line 128 "mini_c.l"
+{ count(); return(')'); }
+	YY_BREAK
+case 81:
+YY_RULE_SETUP
+#line 129 "mini_c.l"
+{ count(); return('['); }
+	YY_BREAK
+case 82:
+YY_RULE_SETUP
+#line 130 "mini_c.l"
+{ count(); return(']'); }
+	YY_BREAK
+case 83:
+YY_RULE_SETUP
+#line 131 "mini_c.l"
+{ count(); return('.'); }
+	YY_BREAK
+case 84:
+YY_RULE_SETUP
+#line 132 "mini_c.l"
+{ count(); return('&'); }
+	YY_BREAK
+case 85:
+YY_RULE_SETUP
+#line 133 "mini_c.l"
+{ count(); return('!'); }
+	YY_BREAK
+case 86:
+YY_RULE_SETUP
+#line 134 "mini_c.l"
+{ count(); return('~'); }
+	YY_BREAK
+case 87:
+YY_RULE_SETUP
+#line 135 "mini_c.l"
+{ count(); return('-'); }
+	YY_BREAK
+case 88:
+YY_RULE_SETUP
+#line 136 "mini_c.l"
+{ count(); return('+'); }
+	YY_BREAK
+case 89:
+YY_RULE_SETUP
+#line 137 "mini_c.l"
+{ count(); return('*'); }
+	YY_BREAK
+case 90:
+YY_RULE_SETUP
+#line 138 "mini_c.l"
+{ count(); return('/'); }
+	YY_BREAK
+case 91:
+YY_RULE_SETUP
+#line 139 "mini_c.l"
+{ count(); return('%'); }
+	YY_BREAK
+case 92:
+YY_RULE_SETUP
+#line 140 "mini_c.l"
+{ count(); return('<'); }
+	YY_BREAK
+case 93:
+YY_RULE_SETUP
+#line 141 "mini_c.l"
+{ count(); return('>'); }
+	YY_BREAK
+case 94:
+YY_RULE_SETUP
+#line 142 "mini_c.l"
+{ count(); return('^'); }
+	YY_BREAK
+case 95:
+YY_RULE_SETUP
+#line 143 "mini_c.l"
+{ count(); return('|'); }
+	YY_BREAK
+case 96:
+YY_RULE_SETUP
+#line 144 "mini_c.l"
+{ count(); return('?'); }
+	YY_BREAK
+case 97:
+/* rule 97 can match eol */
+YY_RULE_SETUP
+#line 146 "mini_c.l"
+{ count(); }
+	YY_BREAK
+case 98:
+YY_RULE_SETUP
+#line 147 "mini_c.l"
+{ /* Add code to complain about unmatched characters */ }
+	YY_BREAK
+case 99:
+YY_RULE_SETUP
+#line 149 "mini_c.l"
+ECHO;
+	YY_BREAK
+#line 1520 "lex.yy.cpp"
+case YY_STATE_EOF(INITIAL):
+	yyterminate();
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = (yy_hold_char);
+		YY_RESTORE_YY_MORE_OFFSET
+
+		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed yyin at a new source and called
+			 * yylex().  If so, then we have to assure
+			 * consistency between YY_CURRENT_BUFFER and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state(  );
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+			yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++(yy_c_buf_p);
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+				yy_cp = (yy_c_buf_p);
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer(  ) )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				(yy_did_buffer_switch_on_eof) = 0;
+
+				if ( yywrap(  ) )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * yytext, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! (yy_did_buffer_switch_on_eof) )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				(yy_c_buf_p) =
+					(yytext_ptr) + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state(  );
+
+				yy_cp = (yy_c_buf_p);
+				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				(yy_c_buf_p) =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
+
+				yy_current_state = yy_get_previous_state(  );
+
+				yy_cp = (yy_c_buf_p);
+				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+	} /* end of user's declarations */
+} /* end of yylex */
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
+ */
+static int yy_get_next_buffer (void)
+{
+    	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+	char *source = (yytext_ptr);
+	int number_to_move, i;
+	int ret_val;
+
+	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a single character, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
+
+	else
+		{
+			int num_to_read =
+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+
+			int yy_c_buf_p_offset =
+				(int) ((yy_c_buf_p) - b->yy_ch_buf);
+
+			if ( b->yy_is_our_buffer )
+				{
+				int new_size = b->yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
+
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					yyrealloc( (void *) b->yy_ch_buf,
+							 (yy_size_t) (b->yy_buf_size + 2)  );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = NULL;
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+						number_to_move - 1;
+
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+			(yy_n_chars), num_to_read );
+
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+		}
+
+	if ( (yy_n_chars) == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart( yyin  );
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+		/* Extend the array by 50%, plus the number we really need. */
+		int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
+		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
+			(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size  );
+		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+		/* "- 2" to take care of EOB's */
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
+	}
+
+	(yy_n_chars) += number_to_move;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
+
+	(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
+
+	return ret_val;
+}
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+    static yy_state_type yy_get_previous_state (void)
+{
+	yy_state_type yy_current_state;
+	char *yy_cp;
+    
+	yy_current_state = (yy_start);
+
+	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
+		{
+		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		if ( yy_accept[yy_current_state] )
+			{
+			(yy_last_accepting_state) = yy_current_state;
+			(yy_last_accepting_cpos) = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 316 )
+				yy_c = yy_meta[yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+		}
+
+	return yy_current_state;
+}
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *	next_state = yy_try_NUL_trans( current_state );
+ */
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
+{
+	int yy_is_jam;
+    	char *yy_cp = (yy_c_buf_p);
+
+	YY_CHAR yy_c = 1;
+	if ( yy_accept[yy_current_state] )
+		{
+		(yy_last_accepting_state) = yy_current_state;
+		(yy_last_accepting_cpos) = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 316 )
+			yy_c = yy_meta[yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+	yy_is_jam = (yy_current_state == 315);
+
+		return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_UNPUT
+
+    static void yyunput (int c, char * yy_bp )
+{
+	char *yy_cp;
+    
+    yy_cp = (yy_c_buf_p);
+
+	/* undo effects of setting up yytext */
+	*yy_cp = (yy_hold_char);
+
+	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+		{ /* need to shift things up to make room */
+		/* +2 for EOB chars. */
+		int number_to_move = (yy_n_chars) + 2;
+		char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
+		char *source =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
+
+		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			*--dest = *--source;
+
+		yy_cp += (int) (dest - source);
+		yy_bp += (int) (dest - source);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+			(yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
+
+		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+			YY_FATAL_ERROR( "flex scanner push-back overflow" );
+		}
+
+	*--yy_cp = (char) c;
+
+    if ( c == '\n' ){
+        --yylineno;
+    }
+
+	(yytext_ptr) = yy_bp;
+	(yy_hold_char) = *yy_cp;
+	(yy_c_buf_p) = yy_cp;
+}
+
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+    static int yyinput (void)
+#else
+    static int input  (void)
+#endif
+
+{
+	int c;
+    
+	*(yy_c_buf_p) = (yy_hold_char);
+
+	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+			/* This was really a NUL. */
+			*(yy_c_buf_p) = '\0';
+
+		else
+			{ /* need more input */
+			int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
+			++(yy_c_buf_p);
+
+			switch ( yy_get_next_buffer(  ) )
+				{
+				case EOB_ACT_LAST_MATCH:
+					/* This happens because yy_g_n_b()
+					 * sees that we've accumulated a
+					 * token and flags that we need to
+					 * try matching the token before
+					 * proceeding.  But for input(),
+					 * there's no matching to consider.
+					 * So convert the EOB_ACT_LAST_MATCH
+					 * to EOB_ACT_END_OF_FILE.
+					 */
+
+					/* Reset buffer status. */
+					yyrestart( yyin );
+
+					/*FALLTHROUGH*/
+
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap(  ) )
+						return 0;
+
+					if ( ! (yy_did_buffer_switch_on_eof) )
+						YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput();
+#else
+					return input();
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					(yy_c_buf_p) = (yytext_ptr) + offset;
+					break;
+				}
+			}
+		}
+
+	c = *(unsigned char *) (yy_c_buf_p);	/* cast for 8-bit char's */
+	*(yy_c_buf_p) = '\0';	/* preserve yytext */
+	(yy_hold_char) = *++(yy_c_buf_p);
+
+	if ( c == '\n' )
+		
+    yylineno++;
+;
+
+	return c;
+}
+#endif	/* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * 
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void yyrestart  (FILE * input_file )
+{
+    
+	if ( ! YY_CURRENT_BUFFER ){
+        yyensure_buffer_stack ();
+		YY_CURRENT_BUFFER_LVALUE =
+            yy_create_buffer( yyin, YY_BUF_SIZE );
+	}
+
+	yy_init_buffer( YY_CURRENT_BUFFER, input_file );
+	yy_load_buffer_state(  );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * 
+ */
+    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
+{
+    
+	/* TODO. We should be able to replace this entire function body
+	 * with
+	 *		yypop_buffer_state();
+	 *		yypush_buffer_state(new_buffer);
+     */
+	yyensure_buffer_stack ();
+	if ( YY_CURRENT_BUFFER == new_buffer )
+		return;
+
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*(yy_c_buf_p) = (yy_hold_char);
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+		}
+
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+	yy_load_buffer_state(  );
+
+	/* We don't actually know whether we did this switch during
+	 * EOF (yywrap()) processing, but the only time this flag
+	 * is looked at is after yywrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	(yy_did_buffer_switch_on_eof) = 1;
+}
+
+static void yy_load_buffer_state  (void)
+{
+    	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+	(yy_hold_char) = *(yy_c_buf_p);
+}
+
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * 
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
+{
+	YY_BUFFER_STATE b;
+    
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_buf_size = size;
+
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2)  );
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_is_our_buffer = 1;
+
+	yy_init_buffer( b, file );
+
+	return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ * 
+ */
+    void yy_delete_buffer (YY_BUFFER_STATE  b )
+{
+    
+	if ( ! b )
+		return;
+
+	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+	if ( b->yy_is_our_buffer )
+		yyfree( (void *) b->yy_ch_buf  );
+
+	yyfree( (void *) b  );
+}
+
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a yyrestart() or at EOF.
+ */
+    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
+
+{
+	int oerrno = errno;
+    
+	yy_flush_buffer( b );
+
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
+
+    /* If b is the current buffer, then yy_init_buffer was _probably_
+     * called from yyrestart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
+
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+    
+	errno = oerrno;
+}
+
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * 
+ */
+    void yy_flush_buffer (YY_BUFFER_STATE  b )
+{
+    	if ( ! b )
+		return;
+
+	b->yy_n_chars = 0;
+
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+	b->yy_buf_pos = &b->yy_ch_buf[0];
+
+	b->yy_at_bol = 1;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	if ( b == YY_CURRENT_BUFFER )
+		yy_load_buffer_state(  );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  
+ */
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
+{
+    	if (new_buffer == NULL)
+		return;
+
+	yyensure_buffer_stack();
+
+	/* This block is copied from yy_switch_to_buffer. */
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*(yy_c_buf_p) = (yy_hold_char);
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+		}
+
+	/* Only push if top exists. Otherwise, replace top. */
+	if (YY_CURRENT_BUFFER)
+		(yy_buffer_stack_top)++;
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+	/* copied from yy_switch_to_buffer. */
+	yy_load_buffer_state(  );
+	(yy_did_buffer_switch_on_eof) = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  
+ */
+void yypop_buffer_state (void)
+{
+    	if (!YY_CURRENT_BUFFER)
+		return;
+
+	yy_delete_buffer(YY_CURRENT_BUFFER );
+	YY_CURRENT_BUFFER_LVALUE = NULL;
+	if ((yy_buffer_stack_top) > 0)
+		--(yy_buffer_stack_top);
+
+	if (YY_CURRENT_BUFFER) {
+		yy_load_buffer_state(  );
+		(yy_did_buffer_switch_on_eof) = 1;
+	}
+}
+
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+static void yyensure_buffer_stack (void)
+{
+	yy_size_t num_to_alloc;
+    
+	if (!(yy_buffer_stack)) {
+
+		/* First allocation is just for 2 elements, since we don't know if this
+		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
+		 * immediate realloc on the next call.
+         */
+      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
+		(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
+								(num_to_alloc * sizeof(struct yy_buffer_state*)
+								);
+		if ( ! (yy_buffer_stack) )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+
+		(yy_buffer_stack_max) = num_to_alloc;
+		(yy_buffer_stack_top) = 0;
+		return;
+	}
+
+	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
+
+		/* Increase the buffer to prepare for a possible push. */
+		yy_size_t grow_size = 8 /* arbitrary grow size */;
+
+		num_to_alloc = (yy_buffer_stack_max) + grow_size;
+		(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
+								((yy_buffer_stack),
+								num_to_alloc * sizeof(struct yy_buffer_state*)
+								);
+		if ( ! (yy_buffer_stack) )
+			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+		/* zero only the new slots.*/
+		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
+		(yy_buffer_stack_max) = num_to_alloc;
+	}
+}
+
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * 
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
+{
+	YY_BUFFER_STATE b;
+    
+	if ( size < 2 ||
+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
+		/* They forgot to leave room for the EOB's. */
+		return NULL;
+
+	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
+	b->yy_buf_pos = b->yy_ch_buf = base;
+	b->yy_is_our_buffer = 0;
+	b->yy_input_file = NULL;
+	b->yy_n_chars = b->yy_buf_size;
+	b->yy_is_interactive = 0;
+	b->yy_at_bol = 1;
+	b->yy_fill_buffer = 0;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	yy_switch_to_buffer( b  );
+
+	return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to yylex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * 
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE yy_scan_string (const char * yystr )
+{
+    
+	return yy_scan_bytes( yystr, (int) strlen(yystr) );
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
+ * scan from a @e copy of @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
+ * 
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len )
+{
+	YY_BUFFER_STATE b;
+	char *buf;
+	yy_size_t n;
+	int i;
+    
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = (yy_size_t) (_yybytes_len + 2);
+	buf = (char *) yyalloc( n  );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+	for ( i = 0; i < _yybytes_len; ++i )
+		buf[i] = yybytes[i];
+
+	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+	b = yy_scan_buffer( buf, n );
+	if ( ! b )
+		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+	/* It's okay to grow etc. this buffer, and we should throw it
+	 * away when we're done.
+	 */
+	b->yy_is_our_buffer = 1;
+
+	return b;
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+static void yynoreturn yy_fatal_error (const char* msg )
+{
+			fprintf( stderr, "%s\n", msg );
+	exit( YY_EXIT_FAILURE );
+}
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		yytext[yyleng] = (yy_hold_char); \
+		(yy_c_buf_p) = yytext + yyless_macro_arg; \
+		(yy_hold_char) = *(yy_c_buf_p); \
+		*(yy_c_buf_p) = '\0'; \
+		yyleng = yyless_macro_arg; \
+		} \
+	while ( 0 )
+
+/* Accessor  methods (get/set functions) to struct members. */
+
+/** Get the current line number.
+ * 
+ */
+int yyget_lineno  (void)
+{
+    
+    return yylineno;
+}
+
+/** Get the input stream.
+ * 
+ */
+FILE *yyget_in  (void)
+{
+        return yyin;
+}
+
+/** Get the output stream.
+ * 
+ */
+FILE *yyget_out  (void)
+{
+        return yyout;
+}
+
+/** Get the length of the current token.
+ * 
+ */
+int yyget_leng  (void)
+{
+        return yyleng;
+}
+
+/** Get the current token.
+ * 
+ */
+
+char *yyget_text  (void)
+{
+        return yytext;
+}
+
+/** Set the current line number.
+ * @param _line_number line number
+ * 
+ */
+void yyset_lineno (int  _line_number )
+{
+    
+    yylineno = _line_number;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param _in_str A readable stream.
+ * 
+ * @see yy_switch_to_buffer
+ */
+void yyset_in (FILE *  _in_str )
+{
+        yyin = _in_str ;
+}
+
+void yyset_out (FILE *  _out_str )
+{
+        yyout = _out_str ;
+}
+
+int yyget_debug  (void)
+{
+        return yy_flex_debug;
+}
+
+void yyset_debug (int  _bdebug )
+{
+        yy_flex_debug = _bdebug ;
+}
+
+static int yy_init_globals (void)
+{
+        /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from yylex_destroy(), so don't allocate here.
+     */
+
+    /* We do not touch yylineno unless the option is enabled. */
+    yylineno =  1;
+    
+    (yy_buffer_stack) = NULL;
+    (yy_buffer_stack_top) = 0;
+    (yy_buffer_stack_max) = 0;
+    (yy_c_buf_p) = NULL;
+    (yy_init) = 0;
+    (yy_start) = 0;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    yyin = stdin;
+    yyout = stdout;
+#else
+    yyin = NULL;
+    yyout = NULL;
+#endif
+
+    /* For future reference: Set errno on error, since we are called by
+     * yylex_init()
+     */
+    return 0;
+}
+
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy  (void)
+{
+    
+    /* Pop the buffer stack, destroying each element. */
+	while(YY_CURRENT_BUFFER){
+		yy_delete_buffer( YY_CURRENT_BUFFER  );
+		YY_CURRENT_BUFFER_LVALUE = NULL;
+		yypop_buffer_state();
+	}
+
+	/* Destroy the stack itself. */
+	yyfree((yy_buffer_stack) );
+	(yy_buffer_stack) = NULL;
+
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * yylex() is called, initialization will occur. */
+    yy_init_globals( );
+
+    return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, const char * s2, int n )
+{
+		
+	int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (const char * s )
+{
+	int n;
+	for ( n = 0; s[n]; ++n )
+		;
+
+	return n;
+}
+#endif
+
+void *yyalloc (yy_size_t  size )
+{
+			return malloc(size);
+}
+
+void *yyrealloc  (void * ptr, yy_size_t  size )
+{
+		
+	/* The cast to (char *) in the following accommodates both
+	 * implementations that use char* generic pointers, and those
+	 * that use void* generic pointers.  It works with the latter
+	 * because both ANSI C and C++ allow castless assignment from
+	 * any pointer type to void*, and deal with argument conversions
+	 * as though doing an assignment.
+	 */
+	return realloc(ptr, size);
+}
+
+void yyfree (void * ptr )
+{
+			free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+#line 149 "mini_c.l"
+
+
+int yywrap(void)
+{
+	return 1;
+}
+
+
+void comment(void)
+{
+	char c, prev = 0;
+
+	while ((c = yyinput()) != 0)      /* (EOF maps to 0) */
+	{
+		if (c == '/' && prev == '*')
+			return;
+		prev = c;
+	}
+	error("unterminated comment");
+}
+
+
+/* int column = 0; */
+
+void count(void)
+{
+	int i;
+
+	for (i = 0; yytext[i] != '\0'; i++)
+		if (yytext[i] == '\n')
+		{
+			column = 0;
+		}
+		else if (yytext[i] == '\t')
+			{
+			column += 8 - (column % 8);
+			}
+		else
+			{
+			column++;
+			}
+	ECHO;
+}
+
+
+int check_type(void)
+{
+/*
+* pseudo code --- this is what it should check
+*
+*	if (yytext == type_name)
+*		return TYPE_NAME;
+*
+*	return IDENTIFIER;
+*/
+
+/*
+*	it actually will only return IDENTIFIER
+*/
+
+	return IDENTIFIER;
+}
diff --git a/main.cpp b/main.cpp
new file mode 100644
index 0000000..fafbdbc
--- /dev/null
+++ b/main.cpp
@@ -0,0 +1,273 @@
+// main.cpp
+#include "ast.h"
+#include "mini_c.tab.hpp" // Bison生成的头文件
+#include <cstdio>
+#include <cstdlib>
+#include <iostream>
+#include <string>
+#include <vector>           // 需要包含 vector
+#include <fstream>          // 需要包含 fstream 用于文件输出
+#include <filesystem>       // 需要包含 filesystem (C++17) 用于路径操作
+
+#include "interpreter.h"    // 可能其他模式需要
+#include "ir.h"             // IR 定义
+#include "semantic.h"       // 语义分析器
+#include "AssemblyGenerator.h" // *** 包含汇编生成器头文件 ***
+#include "ObjectFileGenerator.h"
+#include "InstructionEncoder.h"   // 你的指令编码器
+#include "PrettyPrinter.h"
+
+// 错误处理函数
+void error(const char* msg)
+{
+    // 注意：Bison/Flex 可能在内部调用这个，确保它符合需要
+    // 或者在Flex/Bison中使用 YYERROR 宏
+    std::fprintf(stderr, "Lexer/Parser error: %s\n", msg);
+}
+
+
+extern FILE* yyin; // Flex 使用的输入文件指针
+extern ASTNode *ast_root; // Bison 解析后生成的 AST 根节点 (在 .y 文件中定义)
+
+/*──────────────────────────────
+ * 简易 AST pretty‑printer
+ *─────────────────────────────*/
+// (tag_name, node_loc, print_ast 函数保持不变)
+static const char* tag_name(ASTTag t)
+{
+#define CASE(x) case ASTTag::x: return #x;
+    switch (t) {
+        CASE(ID) CASE(CONST) CASE(STRING)
+        CASE(UNARY) CASE(BINARY) CASE(LOGIC_AND) CASE(LOGIC_OR)
+        CASE(COND) CASE(ASSIGN)
+        CASE(ARRAY_REF) CASE(STRUCT_REF) CASE(FUNC_CALL)
+        CASE(PRE_INC) CASE(PRE_DEC) CASE(POST_INC) CASE(POST_DEC)
+        CASE(SIZEOF_EXPR) CASE(CAST_EXPR) CASE(COMPOUND_LITERAL)
+        CASE(EXPR_LIST) CASE(ARG_LIST)
+
+        CASE(SPECIFIER) CASE(SPEC_LIST) CASE(DECLARATION) CASE(INIT_DECL)
+        CASE(INIT_DECL_LIST) CASE(DECLARATOR) CASE(ARRAY_DECL) CASE(FUNC_DECL)
+        CASE(OLD_FUNC_DECL) CASE(POINTER) CASE(PARAM_DECL) CASE(PARAM_LIST)
+        CASE(ENUM_SPEC) CASE(SU_SPEC) CASE(STRUCT_DECL) CASE(ENUM_CONST)
+        CASE(TYPE_NAME_NODE) CASE(ABS_DECL) CASE(ABS_ARRAY) CASE(ABS_FUNC)
+
+        CASE(INIT_EXPR) CASE(INIT_LIST_NODE) CASE(INIT_ITEM_LIST)
+        CASE(DESIGNATED_INIT) CASE(ARRAY_DESIGNATOR) CASE(FIELD_DESIGNATOR)
+
+        CASE(LABELED_ID_STMT) CASE(CASE_STMT) CASE(DEFAULT_STMT)
+        CASE(COMPOUND_STMT) CASE(EXPR_STMT) CASE(IF_STMT) CASE(SWITCH_STMT)
+        CASE(WHILE_STMT) CASE(DO_WHILE_STMT) CASE(FOR_STMT) CASE(FOR_DECL_STMT)
+        CASE(GOTO_STMT) CASE(CONTINUE_STMT) CASE(BREAK_STMT) CASE(RETURN_STMT)
+        CASE(BLOCK_ITEM_LIST) CASE(BLOCK_DECL) CASE(BLOCK_STMT) // 添加了 BLOCK_DECL
+
+        CASE(TRANSL_UNIT) CASE(DECL_STMT) CASE(FUNCTION_DEF)
+        // 添加其他可能存在的 Tag
+        default: return "UNKNOWN";
+    }
+#undef CASE
+}
+
+static SourceLoc node_loc(const ASTNode* n) {
+    if (!n) return {0, 0};
+    if (n->loc.line || n->loc.col) return n->loc;
+    if (!n->kids.empty() && n->kids[0]) return node_loc(n->kids[0]); // 添加空指针检查
+    return n->loc;
+}
+
+static void print_ast(const ASTNode* n, int indent = 0)
+{
+    if (!n) return;
+    auto l = node_loc(n);
+    std::cout << std::string(indent,' ')
+              << "[" << l.line << ":" << l.col << "] "
+              << tag_name(n->tag) ;
+
+    if (!n->text.empty()) std::cout << " \"" << n->text << "\"";
+    if (n->ival) std::cout << " (" << n->ival << ")";
+    if (n->flag) std::cout << " [flag]";
+    // 打印类型信息（如果存在）
+    if (n->type) std::cout << " {type: " << n->type->toString() << "}";
+
+
+    std::cout << '\n';
+    for (auto* child : n->kids) print_ast(child, indent + 2);
+}
+
+/*──────────────────────────────
+ * main
+ *─────────────────────────────*/
+int main(int argc, char* argv[])
+{
+    if (argc < 3) {
+        std::cerr << "Usage: " << argv[0] << " <operation> <file>\n";
+        std::cerr << "Operations: static_compile, view_ast, view_ir, gen_asm\n";
+        return 1;
+    }
+
+    std::string operation = argv[1];
+    std::string inputFilename = argv[2];
+
+    yyin = std::fopen(inputFilename.c_str(), "r");
+    if (!yyin) {
+        std::perror(inputFilename.c_str());
+        return 2;
+    }
+
+    if (yyparse() == 0 && ast_root != nullptr) {
+        // 1. 语义分析
+        SemanticAnalyzer sema;
+        sema.analyze(ast_root); // 调用 analyze (返回 void)
+
+        // *** 修正错误检查 ***
+        // 通过检查 diagnostics() 的结果来判断是否有错误
+        bool hasSemanticErrors = !sema.diagnostics().empty();
+
+        if (hasSemanticErrors) {
+             std::cerr << "[!] Semantic Errors Detected:\n";
+             for (const auto &d : sema.diagnostics()) { // 直接使用 diagnostics() 获取错误
+                 std::cerr << "  [" << d.loc.line << ":" << d.loc.col << "] Error: "
+                           << d.message << "\n";
+             }
+             std::cerr << "Compilation aborted due to semantic errors.\n";
+             fclose(yyin);
+             return 3; // 返回错误码
+        }
+        // else { // 如果没有错误，可以继续执行
+        //     std::cout << "Semantic analysis successful.\n";
+        // }
+
+        // 2. 根据操作执行不同逻辑 (后续代码保持不变)
+        if (operation == "sc") {
+            std::cout << "Static compilation checks passed (Semantic Analysis).\n";
+        } else if (operation == "ast") {
+            std::cout << "---- Abstract Syntax Tree (AST) ----\n";
+            print_ast(ast_root);
+        } else if (operation == "ir") {
+            // ... (view_ir 代码保持不变) ...
+            auto globalScope = sema.getGlobalScope();
+            if (!globalScope) { // *** 添加检查 ***
+                std::cerr << "FATAL ERROR in main: SemanticAnalyzer::getGlobalScope() returned a null pointer!" << std::endl;
+                fclose(yyin);
+                return 6; // 或者其他错误码
+            }
+            IRGenerator irgen(globalScope);
+            auto quads = irgen.generate(ast_root);
+            std::cout << "\n---- Three-address code (IR) ----\n";
+            for (const auto &q : quads) {
+                printf("%-8s %-8s %-8s -> %-8s",
+                       q.op.c_str(),
+                       q.arg1.c_str(),
+                       q.arg2.c_str(),
+                       q.result.c_str());
+                printf("  @ (%d,%d)", q.loc.line, q.loc.col);
+                if (!q.var.empty()) printf("  var=%s", q.var.c_str());
+                if (q.type) printf("  type=%s", q.type->toString().c_str());
+                printf("\n");
+            }
+        }
+
+        else if (operation == "debug") {
+            auto globalScope = sema.getGlobalScope();
+            IRGenerator irgen(globalScope);
+            auto quads = irgen.generate(ast_root);
+            IRInterpreter interp;
+            interp.runStepByStep(quads);
+        }
+
+        else if (operation == "asm") {
+            // 确保拿到全局符号表
+            auto globalScope = sema.getGlobalScope();
+            if (!globalScope) {
+                std::cerr << "FATAL ERROR in main: SemanticAnalyzer::getGlobalScope() returned a null pointer!" << std::endl;
+                fclose(yyin);
+                return 6;
+            }
+
+            // 生成 IR
+            IRGenerator irgen(globalScope);
+            auto quads = irgen.generate(ast_root);
+
+            // 生成 ARM64 汇编
+            AssemblyGenerator asmGen(quads);
+            std::string asmCode = asmGen.generate();
+
+            // 将汇编代码写入文件
+            std::ofstream outFile("1.s"); // 你可以自定义文件名
+            if (!outFile) {
+                std::cerr << "Error: Failed to open output file for writing!" << std::endl;
+                fclose(yyin);
+                return 7;
+            }
+            outFile << asmCode;
+            outFile.close();
+
+            std::cout << "Assembly code successfully written to '1.s'.\n";
+        }
+
+        else if (operation == "obj") {
+            const char* assemblyFile = "1.s";
+            const char* objectFile = "1.o";
+
+            // 调用系统命令：使用 `as` 汇编器来将 `1.s` 编译成 `1.o`
+            std::string command = "as " + std::string(assemblyFile) + " -o " + std::string(objectFile);
+
+            // 输出命令并执行
+            std::cout << "Running command: " << command << std::endl;
+
+            // 执行命令
+            int result = system(command.c_str());
+
+            // 检查命令是否执行成功
+            if (result == 0) {
+                std::cout << "Compilation successful, " << objectFile << " created." << std::endl;
+            } else {
+                std::cerr << "Error during compilation." << std::endl;
+            }
+        }
+
+        else if (operation == "exec") {
+            const char* objectFile = "1.o";
+            const char* executableFile = "1";
+
+            // 调用系统命令：使用 `g++` 链接器将 `1.o` 链接成可执行文件 `1`
+            std::string command = "g++ " + std::string(objectFile) + " -o " + std::string(executableFile);
+
+            // 输出命令并执行
+            std::cout << "Running command: " << command << std::endl;
+
+            // 执行命令
+            int result = system(command.c_str());
+
+            // 检查命令是否执行成功
+            if (result == 0) {
+                std::cout << "Executable created successfully: " << executableFile << std::endl;
+            } else {
+                std::cerr << "Error during linking." << std::endl;
+            }
+        }
+
+        else if (operation == "pp") {
+            PrettyPrinter pp(std::cout, /*缩进宽度*/ 4);
+            pp.print(ast_root);
+        }
+
+
+        else {
+             std::cerr << "Error: Unknown operation '" << operation << "'\n";
+             std::cerr << "Available operations: static_compile, view_ast, view_ir, gen_asm\n";
+             fclose(yyin);
+             return 1;
+        }
+
+        fclose(yyin);
+        return 0;
+    } else {
+        std::cerr << "Error: Parsing failed";
+        if (ast_root == nullptr && yyin != nullptr) {
+            std::cerr << " (AST generation failed)";
+        }
+         std::cerr << ".\n";
+        if (yyin) fclose(yyin);
+        return 1;
+    }
+}
\ No newline at end of file
diff --git a/mini_c.l b/mini_c.l
new file mode 100644
index 0000000..957f7c2
--- /dev/null
+++ b/mini_c.l
@@ -0,0 +1,210 @@
+D			[0-9]
+L			[a-zA-Z_]
+H			[a-fA-F0-9]
+E			([Ee][+-]?{D}+)
+P                       ([Pp][+-]?{D}+)
+FS			(f|F|l|L)
+IS                      ((u|U)|(u|U)?(l|L|ll|LL)|(l|L|ll|LL)(u|U))
+
+%option yylineno
+
+
+%{
+#include <stdio.h>
+#include <string.h>
+#include "ast.h"
+#include "mini_c.tab.hpp"
+#define SET_SVAL  yylval.sval = strdup(yytext)
+void count(void);
+
+void comment(void);
+
+int column = 0;
+int  check_type(void);
+void error(const char*);   /* 已在 .l 末尾实现 */
+
+extern int yylineno;
+
+#define YY_USER_ACTION                           \
+  yylloc.first_line   = yylineno;                \
+  yylloc.first_column = column;                  \
+  yylloc.last_line    = yylineno;                \
+  yylloc.last_column  = column + yyleng - 1;     \
+  column += yyleng;
+
+
+
+%}
+
+
+%%
+"/*"			{ comment(); }
+
+
+"auto"			{ count(); return(AUTO); }
+"_Bool"			{ count(); return(BOOL); }
+"break"			{ count(); return(BREAK); }
+"case"			{ count(); return(CASE); }
+"char"			{ count(); return(CHAR); }
+"_Complex"		{ count(); return(COMPLEX); }
+"const"			{ count(); return(CONST); }
+"continue"		{ count(); return(CONTINUE); }
+"default"		{ count(); return(DEFAULT); }
+"do"			{ count(); return(DO); }
+"double"		{ count(); return(DOUBLE); }
+"else"			{ count(); return(ELSE); }
+"enum"			{ count(); return(ENUM); }
+"extern"		{ count(); return(EXTERN); }
+"float"			{ count(); return(FLOAT); }
+"for"			{ count(); return(FOR); }
+"goto"			{ count(); return(GOTO); }
+"if"			{ count(); return(IF); }
+"_Imaginary"		{ count(); return(IMAGINARY); }
+"inline"		{ count(); return(INLINE); }
+"int"			{ count(); return(INT); }
+"long"			{ count(); return(LONG); }
+"register"		{ count(); return(REGISTER); }
+"restrict"		{ count(); return(RESTRICT); }
+"return"		{ count(); return(RETURN); }
+"short"			{ count(); return(SHORT); }
+"signed"		{ count(); return(SIGNED); }
+"sizeof"		{ count(); return(SIZEOF); }
+"static"		{ count(); return(STATIC); }
+"struct"		{ count(); return(STRUCT); }
+"switch"		{ count(); return(SWITCH); }
+"typedef"		{ count(); return(TYPEDEF); }
+"union"			{ count(); return(UNION); }
+"unsigned"		{ count(); return(UNSIGNED); }
+"void"			{ count(); return(VOID); }
+"volatile"		{ count(); return(VOLATILE); }
+"while"			{ count(); return(WHILE); }
+
+{L}({L}|{D})*		{ count(); SET_SVAL; return(check_type()); }
+
+0[xX]{H}+{IS}?		{ count(); SET_SVAL; return(CONSTANT); }
+0[0-7]*{IS}?		{ count(); SET_SVAL; return(CONSTANT); }
+[1-9]{D}*{IS}?		{ count(); SET_SVAL; return(CONSTANT); }
+L?'((\\.)|[^\\'\n])+'	{ count(); SET_SVAL; return(CONSTANT); }
+
+{D}+{E}{FS}?		{ count(); SET_SVAL; return(CONSTANT); }
+{D}*\.{D}+{E}?{FS}?	{ count(); SET_SVAL; return(CONSTANT); }
+{D}+\.{D}*{E}?{FS}?	{ count(); SET_SVAL; return(CONSTANT); }
+0[xX]{H}+{P}{FS}?	{ count(); SET_SVAL; return(CONSTANT); }
+0[xX]{H}*\.{H}+{P}?{FS}?     { count(); SET_SVAL; return(CONSTANT); }
+0[xX]{H}+\.{H}*{P}?{FS}?     { count(); SET_SVAL; return(CONSTANT); }
+
+
+L?\"((\\.)|[^\\"\n])*\"	{ count(); SET_SVAL; return(STRING_LITERAL); }
+
+"..."			{ count(); return(ELLIPSIS); }
+">>="			{ count(); return(RIGHT_ASSIGN); }
+"<<="			{ count(); return(LEFT_ASSIGN); }
+"+="			{ count(); return(ADD_ASSIGN); }
+"-="			{ count(); return(SUB_ASSIGN); }
+"*="			{ count(); return(MUL_ASSIGN); }
+"/="			{ count(); return(DIV_ASSIGN); }
+"%="			{ count(); return(MOD_ASSIGN); }
+"&="			{ count(); return(AND_ASSIGN); }
+"^="			{ count(); return(XOR_ASSIGN); }
+"|="			{ count(); return(OR_ASSIGN); }
+">>"			{ count(); return(RIGHT_OP); }
+"<<"			{ count(); return(LEFT_OP); }
+"++"			{ count(); return(INC_OP); }
+"--"			{ count(); return(DEC_OP); }
+"->"			{ count(); return(PTR_OP); }
+"&&"			{ count(); return(AND_OP); }
+"||"			{ count(); return(OR_OP); }
+"<="			{ count(); return(LE_OP); }
+">="			{ count(); return(GE_OP); }
+"=="			{ count(); return(EQ_OP); }
+"!="			{ count(); return(NE_OP); }
+";"			{ count(); return(';'); }
+(\{|<%)		{ count(); return('{'); }
+(\}|%>)		{ count(); return('}'); }
+","			{ count(); return(','); }
+":"			{ count(); return(':'); }
+"="			{ count(); return('='); }
+"("			{ count(); return('('); }
+")"			{ count(); return(')'); }
+(\[|<:)		{ count(); return('['); }
+(\]|:>)		{ count(); return(']'); }
+"."			{ count(); return('.'); }
+"&"			{ count(); return('&'); }
+"!"			{ count(); return('!'); }
+"~"			{ count(); return('~'); }
+"-"			{ count(); return('-'); }
+"+"			{ count(); return('+'); }
+"*"			{ count(); return('*'); }
+"/"			{ count(); return('/'); }
+"%"			{ count(); return('%'); }
+"<"			{ count(); return('<'); }
+">"			{ count(); return('>'); }
+"^"			{ count(); return('^'); }
+"|"			{ count(); return('|'); }
+"?"			{ count(); return('?'); }
+
+[\p\t\v\n\f]		{ count(); }
+.			{ /* Add code to complain about unmatched characters */ }
+
+%%
+
+int yywrap(void)
+{
+	return 1;
+}
+
+
+void comment(void)
+{
+	char c, prev = 0;
+
+	while ((c = yyinput()) != 0)      /* (EOF maps to 0) */
+	{
+		if (c == '/' && prev == '*')
+			return;
+		prev = c;
+	}
+	error("unterminated comment");
+}
+
+
+/* int column = 0; */
+
+void count(void)
+{
+	int i;
+
+	for (i = 0; yytext[i] != '\0'; i++)
+		if (yytext[i] == '\n')
+		{
+			column = 0;
+		}
+		else if (yytext[i] == '\t')
+			{
+			column += 8 - (column % 8);
+			}
+		else
+			{
+			column++;
+			}
+	ECHO;
+}
+
+
+int check_type(void)
+{
+/*
+* pseudo code --- this is what it should check
+*
+*	if (yytext == type_name)
+*		return TYPE_NAME;
+*
+*	return IDENTIFIER;
+*/
+
+/*
+*	it actually will only return IDENTIFIER
+*/
+
+	return IDENTIFIER;
+}
\ No newline at end of file
diff --git a/mini_c.tab.cpp b/mini_c.tab.cpp
new file mode 100644
index 0000000..cb4c833
--- /dev/null
+++ b/mini_c.tab.cpp
@@ -0,0 +1,3529 @@
+/* A Bison parser, made by GNU Bison 3.8.2.  */
+
+/* Bison implementation for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
+   Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */
+
+/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
+   especially those whose name start with YY_ or yy_.  They are
+   private implementation details that can be changed or removed.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output, and Bison version.  */
+#define YYBISON 30802
+/* Bison version string.  */
+#define YYBISON_VERSION "3.8.2"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 0
+
+/* Push parsers.  */
+#define YYPUSH 0
+
+/* Pull parsers.  */
+#define YYPULL 1
+
+
+
+
+/* First part of user prologue.  */
+#line 3 "mini_c.y"
+
+#include <stdio.h>
+#include "ast.h"            /* 定义了 ASTNode 结构和 new_* 系列函数 */
+ASTNode *ast_root = NULL;  /* 最终的 AST 根 */
+int yylex(void);
+void yyerror(const char *s);
+
+#define LOC(YYL) SourceLoc{ (YYL).first_line, (YYL).first_column }
+
+static ASTNode* make_type_spec_node(int ts)
+{
+    ASTNode* n = new ASTNode(ASTTag::SPECIFIER);
+    n->ival = ts;
+    return n;
+}
+
+
+#line 89 "mini_c.tab.cpp"
+
+# ifndef YY_CAST
+#  ifdef __cplusplus
+#   define YY_CAST(Type, Val) static_cast<Type> (Val)
+#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
+#  else
+#   define YY_CAST(Type, Val) ((Type) (Val))
+#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
+#  endif
+# endif
+# ifndef YY_NULLPTR
+#  if defined __cplusplus
+#   if 201103L <= __cplusplus
+#    define YY_NULLPTR nullptr
+#   else
+#    define YY_NULLPTR 0
+#   endif
+#  else
+#   define YY_NULLPTR ((void*)0)
+#  endif
+# endif
+
+#include "mini_c.tab.hpp"
+/* Symbol kind.  */
+enum yysymbol_kind_t
+{
+  YYSYMBOL_YYEMPTY = -2,
+  YYSYMBOL_YYEOF = 0,                      /* "end of file"  */
+  YYSYMBOL_YYerror = 1,                    /* error  */
+  YYSYMBOL_YYUNDEF = 2,                    /* "invalid token"  */
+  YYSYMBOL_LOWER_THAN_ELSE = 3,            /* LOWER_THAN_ELSE  */
+  YYSYMBOL_IDENTIFIER = 4,                 /* IDENTIFIER  */
+  YYSYMBOL_CONSTANT = 5,                   /* CONSTANT  */
+  YYSYMBOL_STRING_LITERAL = 6,             /* STRING_LITERAL  */
+  YYSYMBOL_TYPE_NAME = 7,                  /* TYPE_NAME  */
+  YYSYMBOL_SIZEOF = 8,                     /* SIZEOF  */
+  YYSYMBOL_PTR_OP = 9,                     /* PTR_OP  */
+  YYSYMBOL_INC_OP = 10,                    /* INC_OP  */
+  YYSYMBOL_DEC_OP = 11,                    /* DEC_OP  */
+  YYSYMBOL_LEFT_OP = 12,                   /* LEFT_OP  */
+  YYSYMBOL_RIGHT_OP = 13,                  /* RIGHT_OP  */
+  YYSYMBOL_LE_OP = 14,                     /* LE_OP  */
+  YYSYMBOL_GE_OP = 15,                     /* GE_OP  */
+  YYSYMBOL_EQ_OP = 16,                     /* EQ_OP  */
+  YYSYMBOL_NE_OP = 17,                     /* NE_OP  */
+  YYSYMBOL_AND_OP = 18,                    /* AND_OP  */
+  YYSYMBOL_OR_OP = 19,                     /* OR_OP  */
+  YYSYMBOL_MUL_ASSIGN = 20,                /* MUL_ASSIGN  */
+  YYSYMBOL_DIV_ASSIGN = 21,                /* DIV_ASSIGN  */
+  YYSYMBOL_MOD_ASSIGN = 22,                /* MOD_ASSIGN  */
+  YYSYMBOL_ADD_ASSIGN = 23,                /* ADD_ASSIGN  */
+  YYSYMBOL_SUB_ASSIGN = 24,                /* SUB_ASSIGN  */
+  YYSYMBOL_LEFT_ASSIGN = 25,               /* LEFT_ASSIGN  */
+  YYSYMBOL_RIGHT_ASSIGN = 26,              /* RIGHT_ASSIGN  */
+  YYSYMBOL_AND_ASSIGN = 27,                /* AND_ASSIGN  */
+  YYSYMBOL_XOR_ASSIGN = 28,                /* XOR_ASSIGN  */
+  YYSYMBOL_OR_ASSIGN = 29,                 /* OR_ASSIGN  */
+  YYSYMBOL_TYPEDEF = 30,                   /* TYPEDEF  */
+  YYSYMBOL_EXTERN = 31,                    /* EXTERN  */
+  YYSYMBOL_STATIC = 32,                    /* STATIC  */
+  YYSYMBOL_AUTO = 33,                      /* AUTO  */
+  YYSYMBOL_REGISTER = 34,                  /* REGISTER  */
+  YYSYMBOL_INLINE = 35,                    /* INLINE  */
+  YYSYMBOL_RESTRICT = 36,                  /* RESTRICT  */
+  YYSYMBOL_CHAR = 37,                      /* CHAR  */
+  YYSYMBOL_SHORT = 38,                     /* SHORT  */
+  YYSYMBOL_INT = 39,                       /* INT  */
+  YYSYMBOL_LONG = 40,                      /* LONG  */
+  YYSYMBOL_SIGNED = 41,                    /* SIGNED  */
+  YYSYMBOL_UNSIGNED = 42,                  /* UNSIGNED  */
+  YYSYMBOL_FLOAT = 43,                     /* FLOAT  */
+  YYSYMBOL_DOUBLE = 44,                    /* DOUBLE  */
+  YYSYMBOL_CONST = 45,                     /* CONST  */
+  YYSYMBOL_VOLATILE = 46,                  /* VOLATILE  */
+  YYSYMBOL_VOID = 47,                      /* VOID  */
+  YYSYMBOL_BOOL = 48,                      /* BOOL  */
+  YYSYMBOL_COMPLEX = 49,                   /* COMPLEX  */
+  YYSYMBOL_IMAGINARY = 50,                 /* IMAGINARY  */
+  YYSYMBOL_STRUCT = 51,                    /* STRUCT  */
+  YYSYMBOL_UNION = 52,                     /* UNION  */
+  YYSYMBOL_ENUM = 53,                      /* ENUM  */
+  YYSYMBOL_ELLIPSIS = 54,                  /* ELLIPSIS  */
+  YYSYMBOL_CASE = 55,                      /* CASE  */
+  YYSYMBOL_DEFAULT = 56,                   /* DEFAULT  */
+  YYSYMBOL_IF = 57,                        /* IF  */
+  YYSYMBOL_ELSE = 58,                      /* ELSE  */
+  YYSYMBOL_SWITCH = 59,                    /* SWITCH  */
+  YYSYMBOL_WHILE = 60,                     /* WHILE  */
+  YYSYMBOL_DO = 61,                        /* DO  */
+  YYSYMBOL_FOR = 62,                       /* FOR  */
+  YYSYMBOL_GOTO = 63,                      /* GOTO  */
+  YYSYMBOL_CONTINUE = 64,                  /* CONTINUE  */
+  YYSYMBOL_BREAK = 65,                     /* BREAK  */
+  YYSYMBOL_RETURN = 66,                    /* RETURN  */
+  YYSYMBOL_67_ = 67,                       /* '('  */
+  YYSYMBOL_68_ = 68,                       /* ')'  */
+  YYSYMBOL_69_ = 69,                       /* '['  */
+  YYSYMBOL_70_ = 70,                       /* ']'  */
+  YYSYMBOL_71_ = 71,                       /* '.'  */
+  YYSYMBOL_72_ = 72,                       /* '{'  */
+  YYSYMBOL_73_ = 73,                       /* '}'  */
+  YYSYMBOL_74_ = 74,                       /* ','  */
+  YYSYMBOL_75_ = 75,                       /* '&'  */
+  YYSYMBOL_76_ = 76,                       /* '*'  */
+  YYSYMBOL_77_ = 77,                       /* '+'  */
+  YYSYMBOL_78_ = 78,                       /* '-'  */
+  YYSYMBOL_79_ = 79,                       /* '~'  */
+  YYSYMBOL_80_ = 80,                       /* '!'  */
+  YYSYMBOL_81_ = 81,                       /* '/'  */
+  YYSYMBOL_82_ = 82,                       /* '%'  */
+  YYSYMBOL_83_ = 83,                       /* '<'  */
+  YYSYMBOL_84_ = 84,                       /* '>'  */
+  YYSYMBOL_85_ = 85,                       /* '^'  */
+  YYSYMBOL_86_ = 86,                       /* '|'  */
+  YYSYMBOL_87_ = 87,                       /* '?'  */
+  YYSYMBOL_88_ = 88,                       /* ':'  */
+  YYSYMBOL_89_ = 89,                       /* '='  */
+  YYSYMBOL_90_ = 90,                       /* ';'  */
+  YYSYMBOL_YYACCEPT = 91,                  /* $accept  */
+  YYSYMBOL_primary_expression = 92,        /* primary_expression  */
+  YYSYMBOL_postfix_expression = 93,        /* postfix_expression  */
+  YYSYMBOL_argument_expression_list = 94,  /* argument_expression_list  */
+  YYSYMBOL_unary_expression = 95,          /* unary_expression  */
+  YYSYMBOL_unary_operator = 96,            /* unary_operator  */
+  YYSYMBOL_cast_expression = 97,           /* cast_expression  */
+  YYSYMBOL_multiplicative_expression = 98, /* multiplicative_expression  */
+  YYSYMBOL_additive_expression = 99,       /* additive_expression  */
+  YYSYMBOL_shift_expression = 100,         /* shift_expression  */
+  YYSYMBOL_relational_expression = 101,    /* relational_expression  */
+  YYSYMBOL_equality_expression = 102,      /* equality_expression  */
+  YYSYMBOL_and_expression = 103,           /* and_expression  */
+  YYSYMBOL_exclusive_or_expression = 104,  /* exclusive_or_expression  */
+  YYSYMBOL_inclusive_or_expression = 105,  /* inclusive_or_expression  */
+  YYSYMBOL_logical_and_expression = 106,   /* logical_and_expression  */
+  YYSYMBOL_logical_or_expression = 107,    /* logical_or_expression  */
+  YYSYMBOL_conditional_expression = 108,   /* conditional_expression  */
+  YYSYMBOL_assignment_expression = 109,    /* assignment_expression  */
+  YYSYMBOL_assignment_operator = 110,      /* assignment_operator  */
+  YYSYMBOL_expression = 111,               /* expression  */
+  YYSYMBOL_constant_expression = 112,      /* constant_expression  */
+  YYSYMBOL_declaration = 113,              /* declaration  */
+  YYSYMBOL_declaration_specifiers = 114,   /* declaration_specifiers  */
+  YYSYMBOL_init_declarator_list = 115,     /* init_declarator_list  */
+  YYSYMBOL_init_declarator = 116,          /* init_declarator  */
+  YYSYMBOL_storage_class_specifier = 117,  /* storage_class_specifier  */
+  YYSYMBOL_type_specifier = 118,           /* type_specifier  */
+  YYSYMBOL_struct_or_union_specifier = 119, /* struct_or_union_specifier  */
+  YYSYMBOL_struct_or_union = 120,          /* struct_or_union  */
+  YYSYMBOL_struct_declaration_list = 121,  /* struct_declaration_list  */
+  YYSYMBOL_struct_declaration = 122,       /* struct_declaration  */
+  YYSYMBOL_specifier_qualifier_list = 123, /* specifier_qualifier_list  */
+  YYSYMBOL_struct_declarator_list = 124,   /* struct_declarator_list  */
+  YYSYMBOL_struct_declarator = 125,        /* struct_declarator  */
+  YYSYMBOL_enum_specifier = 126,           /* enum_specifier  */
+  YYSYMBOL_enumerator_list = 127,          /* enumerator_list  */
+  YYSYMBOL_enumerator = 128,               /* enumerator  */
+  YYSYMBOL_type_qualifier = 129,           /* type_qualifier  */
+  YYSYMBOL_function_specifier = 130,       /* function_specifier  */
+  YYSYMBOL_declarator = 131,               /* declarator  */
+  YYSYMBOL_direct_declarator = 132,        /* direct_declarator  */
+  YYSYMBOL_pointer = 133,                  /* pointer  */
+  YYSYMBOL_type_qualifier_list = 134,      /* type_qualifier_list  */
+  YYSYMBOL_parameter_type_list = 135,      /* parameter_type_list  */
+  YYSYMBOL_parameter_list = 136,           /* parameter_list  */
+  YYSYMBOL_parameter_declaration = 137,    /* parameter_declaration  */
+  YYSYMBOL_identifier_list = 138,          /* identifier_list  */
+  YYSYMBOL_type_name = 139,                /* type_name  */
+  YYSYMBOL_abstract_declarator = 140,      /* abstract_declarator  */
+  YYSYMBOL_direct_abstract_declarator = 141, /* direct_abstract_declarator  */
+  YYSYMBOL_initializer = 142,              /* initializer  */
+  YYSYMBOL_initializer_list = 143,         /* initializer_list  */
+  YYSYMBOL_designation = 144,              /* designation  */
+  YYSYMBOL_designator_list = 145,          /* designator_list  */
+  YYSYMBOL_designator = 146,               /* designator  */
+  YYSYMBOL_statement = 147,                /* statement  */
+  YYSYMBOL_labeled_statement = 148,        /* labeled_statement  */
+  YYSYMBOL_compound_statement = 149,       /* compound_statement  */
+  YYSYMBOL_block_item_list = 150,          /* block_item_list  */
+  YYSYMBOL_block_item = 151,               /* block_item  */
+  YYSYMBOL_expression_statement = 152,     /* expression_statement  */
+  YYSYMBOL_selection_statement = 153,      /* selection_statement  */
+  YYSYMBOL_iteration_statement = 154,      /* iteration_statement  */
+  YYSYMBOL_jump_statement = 155,           /* jump_statement  */
+  YYSYMBOL_translation_unit = 156,         /* translation_unit  */
+  YYSYMBOL_external_declaration = 157,     /* external_declaration  */
+  YYSYMBOL_function_definition = 158,      /* function_definition  */
+  YYSYMBOL_declaration_list = 159          /* declaration_list  */
+};
+typedef enum yysymbol_kind_t yysymbol_kind_t;
+
+
+
+
+#ifdef short
+# undef short
+#endif
+
+/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
+   <limits.h> and (if available) <stdint.h> are included
+   so that the code can choose integer types of a good width.  */
+
+#ifndef __PTRDIFF_MAX__
+# include <limits.h> /* INFRINGES ON USER NAME SPACE */
+# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
+#  include <stdint.h> /* INFRINGES ON USER NAME SPACE */
+#  define YY_STDINT_H
+# endif
+#endif
+
+/* Narrow types that promote to a signed type and that can represent a
+   signed or unsigned integer of at least N bits.  In tables they can
+   save space and decrease cache pressure.  Promoting to a signed type
+   helps avoid bugs in integer arithmetic.  */
+
+#ifdef __INT_LEAST8_MAX__
+typedef __INT_LEAST8_TYPE__ yytype_int8;
+#elif defined YY_STDINT_H
+typedef int_least8_t yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef __INT_LEAST16_MAX__
+typedef __INT_LEAST16_TYPE__ yytype_int16;
+#elif defined YY_STDINT_H
+typedef int_least16_t yytype_int16;
+#else
+typedef short yytype_int16;
+#endif
+
+/* Work around bug in HP-UX 11.23, which defines these macros
+   incorrectly for preprocessor constants.  This workaround can likely
+   be removed in 2023, as HPE has promised support for HP-UX 11.23
+   (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
+   <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>.  */
+#ifdef __hpux
+# undef UINT_LEAST8_MAX
+# undef UINT_LEAST16_MAX
+# define UINT_LEAST8_MAX 255
+# define UINT_LEAST16_MAX 65535
+#endif
+
+#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
+typedef __UINT_LEAST8_TYPE__ yytype_uint8;
+#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
+       && UINT_LEAST8_MAX <= INT_MAX)
+typedef uint_least8_t yytype_uint8;
+#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
+typedef unsigned char yytype_uint8;
+#else
+typedef short yytype_uint8;
+#endif
+
+#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
+typedef __UINT_LEAST16_TYPE__ yytype_uint16;
+#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
+       && UINT_LEAST16_MAX <= INT_MAX)
+typedef uint_least16_t yytype_uint16;
+#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
+typedef unsigned short yytype_uint16;
+#else
+typedef int yytype_uint16;
+#endif
+
+#ifndef YYPTRDIFF_T
+# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
+#  define YYPTRDIFF_T __PTRDIFF_TYPE__
+#  define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
+# elif defined PTRDIFF_MAX
+#  ifndef ptrdiff_t
+#   include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  endif
+#  define YYPTRDIFF_T ptrdiff_t
+#  define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
+# else
+#  define YYPTRDIFF_T long
+#  define YYPTRDIFF_MAXIMUM LONG_MAX
+# endif
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# else
+#  define YYSIZE_T unsigned
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM                                  \
+  YY_CAST (YYPTRDIFF_T,                                 \
+           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
+            ? YYPTRDIFF_MAXIMUM                         \
+            : YY_CAST (YYSIZE_T, -1)))
+
+#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
+
+
+/* Stored state numbers (used for stacks). */
+typedef yytype_int16 yy_state_t;
+
+/* State numbers in computations.  */
+typedef int yy_state_fast_t;
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(Msgid) Msgid
+# endif
+#endif
+
+
+#ifndef YY_ATTRIBUTE_PURE
+# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
+#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
+# else
+#  define YY_ATTRIBUTE_PURE
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
+#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
+# else
+#  define YY_ATTRIBUTE_UNUSED
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E.  */
+#if ! defined lint || defined __GNUC__
+# define YY_USE(E) ((void) (E))
+#else
+# define YY_USE(E) /* empty */
+#endif
+
+/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
+#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
+# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
+#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \
+    _Pragma ("GCC diagnostic push")                                     \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
+# else
+#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \
+    _Pragma ("GCC diagnostic push")                                     \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \
+    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# endif
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \
+    _Pragma ("GCC diagnostic pop")
+#else
+# define YY_INITIAL_VALUE(Value) Value
+#endif
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
+#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
+# define YY_IGNORE_USELESS_CAST_BEGIN                          \
+    _Pragma ("GCC diagnostic push")                            \
+    _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
+# define YY_IGNORE_USELESS_CAST_END            \
+    _Pragma ("GCC diagnostic pop")
+#endif
+#ifndef YY_IGNORE_USELESS_CAST_BEGIN
+# define YY_IGNORE_USELESS_CAST_BEGIN
+# define YY_IGNORE_USELESS_CAST_END
+#endif
+
+
+#define YY_ASSERT(E) ((void) (0 && (E)))
+
+#if !defined yyoverflow
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
+#     ifndef EXIT_SUCCESS
+#      define EXIT_SUCCESS 0
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's 'empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
+       && ! ((defined YYMALLOC || defined malloc) \
+             && (defined YYFREE || defined free)))
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   ifndef EXIT_SUCCESS
+#    define EXIT_SUCCESS 0
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+# endif
+#endif /* !defined yyoverflow */
+
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+         || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
+             && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  yy_state_t yyss_alloc;
+  YYSTYPE yyvs_alloc;
+  YYLTYPE yyls_alloc;
+};
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \
+             + YYSIZEOF (YYLTYPE)) \
+      + 2 * YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
+    do                                                                  \
+      {                                                                 \
+        YYPTRDIFF_T yynewbytes;                                         \
+        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
+        Stack = &yyptr->Stack_alloc;                                    \
+        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
+        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
+      }                                                                 \
+    while (0)
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from SRC to DST.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(Dst, Src, Count) \
+      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
+#  else
+#   define YYCOPY(Dst, Src, Count)              \
+      do                                        \
+        {                                       \
+          YYPTRDIFF_T yyi;                      \
+          for (yyi = 0; yyi < (Count); yyi++)   \
+            (Dst)[yyi] = (Src)[yyi];            \
+        }                                       \
+      while (0)
+#  endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state.  */
+#define YYFINAL  55
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   1631
+
+/* YYNTOKENS -- Number of terminals.  */
+#define YYNTOKENS  91
+/* YYNNTS -- Number of nonterminals.  */
+#define YYNNTS  69
+/* YYNRULES -- Number of rules.  */
+#define YYNRULES  238
+/* YYNSTATES -- Number of states.  */
+#define YYNSTATES  400
+
+/* YYMAXUTOK -- Last valid token kind.  */
+#define YYMAXUTOK   321
+
+
+/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex, with out-of-bounds checking.  */
+#define YYTRANSLATE(YYX)                                \
+  (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
+   ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
+   : YYSYMBOL_YYUNDEF)
+
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex.  */
+static const yytype_int8 yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,    80,     2,     2,     2,    82,    75,     2,
+      67,    68,    76,    77,    74,    78,    71,    81,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,    88,    90,
+      83,    89,    84,    87,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,    69,     2,    70,    85,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,    72,    86,    73,    79,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
+      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
+      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
+      65,    66
+};
+
+#if YYDEBUG
+/* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
+static const yytype_int16 yyrline[] =
+{
+       0,   144,   144,   145,   146,   147,   151,   152,   153,   154,
+     155,   156,   157,   158,   159,   160,   165,   166,   170,   171,
+     172,   173,   174,   175,   179,   180,   181,   182,   183,   184,
+     189,   190,   194,   195,   196,   197,   202,   203,   204,   209,
+     210,   211,   216,   217,   218,   219,   220,   225,   226,   227,
+     233,   235,   241,   243,   249,   251,   257,   259,   265,   267,
+     273,   275,   281,   283,   289,   290,   291,   292,   293,   294,
+     295,   296,   297,   298,   299,   303,   305,   311,   317,   319,
+     325,   327,   329,   331,   333,   335,   337,   339,   345,   347,
+     353,   355,   361,   362,   363,   364,   365,   369,   370,   371,
+     372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
+     383,   385,   390,   392,   394,   401,   402,   406,   408,   414,
+     419,   421,   423,   425,   431,   433,   439,   441,   443,   449,
+     451,   453,   455,   457,   463,   465,   471,   473,   479,   481,
+     483,   488,   493,   495,   501,   503,   505,   507,   509,   511,
+     513,   515,   517,   519,   521,   523,   525,   531,   533,   535,
+     537,   543,   545,   550,   552,   558,   560,   566,   568,   570,
+     576,   578,   583,   585,   591,   593,   595,   601,   603,   605,
+     607,   609,   611,   613,   615,   617,   619,   621,   627,   629,
+     631,   637,   639,   641,   643,   649,   655,   657,   662,   664,
+     670,   671,   672,   673,   674,   675,   680,   682,   684,   689,
+     691,   697,   699,   705,   707,   713,   715,   720,   722,   724,
+     729,   731,   733,   735,   737,   739,   745,   747,   749,   751,
+     753,   759,   761,   766,   768,   774,   776,   782,   784
+};
+#endif
+
+/** Accessing symbol of state STATE.  */
+#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
+
+#if YYDEBUG || 0
+/* The user-facing name of the symbol whose (internal) number is
+   YYSYMBOL.  No bounds checking.  */
+static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
+
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+static const char *const yytname[] =
+{
+  "\"end of file\"", "error", "\"invalid token\"", "LOWER_THAN_ELSE",
+  "IDENTIFIER", "CONSTANT", "STRING_LITERAL", "TYPE_NAME", "SIZEOF",
+  "PTR_OP", "INC_OP", "DEC_OP", "LEFT_OP", "RIGHT_OP", "LE_OP", "GE_OP",
+  "EQ_OP", "NE_OP", "AND_OP", "OR_OP", "MUL_ASSIGN", "DIV_ASSIGN",
+  "MOD_ASSIGN", "ADD_ASSIGN", "SUB_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN",
+  "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", "TYPEDEF", "EXTERN", "STATIC",
+  "AUTO", "REGISTER", "INLINE", "RESTRICT", "CHAR", "SHORT", "INT", "LONG",
+  "SIGNED", "UNSIGNED", "FLOAT", "DOUBLE", "CONST", "VOLATILE", "VOID",
+  "BOOL", "COMPLEX", "IMAGINARY", "STRUCT", "UNION", "ENUM", "ELLIPSIS",
+  "CASE", "DEFAULT", "IF", "ELSE", "SWITCH", "WHILE", "DO", "FOR", "GOTO",
+  "CONTINUE", "BREAK", "RETURN", "'('", "')'", "'['", "']'", "'.'", "'{'",
+  "'}'", "','", "'&'", "'*'", "'+'", "'-'", "'~'", "'!'", "'/'", "'%'",
+  "'<'", "'>'", "'^'", "'|'", "'?'", "':'", "'='", "';'", "$accept",
+  "primary_expression", "postfix_expression", "argument_expression_list",
+  "unary_expression", "unary_operator", "cast_expression",
+  "multiplicative_expression", "additive_expression", "shift_expression",
+  "relational_expression", "equality_expression", "and_expression",
+  "exclusive_or_expression", "inclusive_or_expression",
+  "logical_and_expression", "logical_or_expression",
+  "conditional_expression", "assignment_expression", "assignment_operator",
+  "expression", "constant_expression", "declaration",
+  "declaration_specifiers", "init_declarator_list", "init_declarator",
+  "storage_class_specifier", "type_specifier", "struct_or_union_specifier",
+  "struct_or_union", "struct_declaration_list", "struct_declaration",
+  "specifier_qualifier_list", "struct_declarator_list",
+  "struct_declarator", "enum_specifier", "enumerator_list", "enumerator",
+  "type_qualifier", "function_specifier", "declarator",
+  "direct_declarator", "pointer", "type_qualifier_list",
+  "parameter_type_list", "parameter_list", "parameter_declaration",
+  "identifier_list", "type_name", "abstract_declarator",
+  "direct_abstract_declarator", "initializer", "initializer_list",
+  "designation", "designator_list", "designator", "statement",
+  "labeled_statement", "compound_statement", "block_item_list",
+  "block_item", "expression_statement", "selection_statement",
+  "iteration_statement", "jump_statement", "translation_unit",
+  "external_declaration", "function_definition", "declaration_list", YY_NULLPTR
+};
+
+static const char *
+yysymbol_name (yysymbol_kind_t yysymbol)
+{
+  return yytname[yysymbol];
+}
+#endif
+
+#define YYPACT_NINF (-309)
+
+#define yypact_value_is_default(Yyn) \
+  ((Yyn) == YYPACT_NINF)
+
+#define YYTABLE_NINF (-1)
+
+#define yytable_value_is_error(Yyn) \
+  0
+
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+   STATE-NUM.  */
+static const yytype_int16 yypact[] =
+{
+    1578,  -309,  -309,  -309,  -309,  -309,  -309,  -309,  -309,  -309,
+    -309,  -309,  -309,  -309,  -309,  -309,  -309,  -309,  -309,  -309,
+    -309,  -309,  -309,  -309,  -309,    46,  -309,    26,  1578,  1578,
+    -309,    47,  -309,  1578,  1578,  1483,  -309,  -309,   -17,    62,
+    -309,    58,   110,  -309,   -29,  -309,   313,    66,    22,  -309,
+    -309,    13,   331,  -309,  -309,  -309,  -309,    62,     1,   178,
+    -309,    83,  -309,  -309,   110,    58,  -309,   393,   913,  -309,
+      26,  -309,  1332,  1382,   725,    66,   331,   331,  1267,  -309,
+      53,   331,   193,  1076,  -309,    15,  -309,  -309,  -309,  -309,
+      14,    96,  -309,  -309,  1092,  1169,  1169,  1076,   101,   109,
+     130,   162,   597,   166,   216,   152,   158,   565,   702,  -309,
+    -309,  -309,  -309,  -309,  -309,  -309,  -309,  -309,    73,   697,
+    1076,  -309,   112,   -41,   258,    54,   265,   180,   179,   182,
+     271,    35,  -309,  -309,   -18,  -309,  -309,  -309,  -309,   470,
+    -309,  -309,  -309,  -309,  -309,  -309,   822,  -309,  -309,  -309,
+    -309,  -309,  -309,    48,   215,   224,  -309,    33,   103,  -309,
+     238,   242,   779,  1285,  -309,  -309,  -309,  1076,   -10,  -309,
+     225,  -309,  -309,    19,  -309,  -309,  -309,  -309,  -309,   597,
+     702,  -309,   702,  -309,  -309,   229,   597,  1076,  1076,  1076,
+     243,   547,   228,  -309,  -309,  -309,    -9,    84,   106,   251,
+     317,  -309,  -309,   928,  1076,   318,  -309,  -309,  -309,  -309,
+    -309,  -309,  -309,  -309,  -309,  -309,  -309,  1076,  -309,  1076,
+    1076,  1076,  1076,  1076,  1076,  1076,  1076,  1076,  1076,  1076,
+    1076,  1076,  1076,  1076,  1076,  1076,  1076,  1076,  1076,  -309,
+    -309,  -309,  1076,   319,  -309,   218,   913,    88,  -309,  1153,
+     942,  -309,    63,  -309,   129,  -309,  1530,  -309,   320,   899,
+    -309,  -309,  1076,  -309,   255,   256,  -309,  -309,    53,  -309,
+    1076,  -309,  -309,   261,   262,   597,  -309,    86,   100,   117,
+     266,   625,   625,  -309,  -309,  -309,  1220,   176,  -309,   957,
+    -309,  -309,   150,  -309,   170,  -309,  -309,  -309,  -309,  -309,
+     112,   112,   -41,   -41,   258,   258,   258,   258,    54,    54,
+     265,   180,   179,   182,   271,   -28,  -309,   264,  -309,  -309,
+     159,  -309,  -309,  -309,  -309,   267,   269,  -309,   270,   272,
+     129,  1429,  1034,  -309,  -309,  -309,   316,   322,  -309,  -309,
+    -309,  -309,   260,   260,  -309,   597,   597,   597,  1076,  1048,
+    1062,   822,  -309,  -309,  1076,  -309,  1076,  -309,  -309,  -309,
+     913,  -309,  -309,  -309,  -309,  -309,   321,  -309,   323,   324,
+    -309,  -309,   281,  -309,  -309,   151,   597,   153,   597,   173,
+     222,  -309,  -309,  -309,  -309,  -309,  -309,   597,   297,  -309,
+     597,  -309,   597,  -309,   802,  -309,  -309,  -309,  -309,  -309
+};
+
+/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+   Performed when YYTABLE does not specify something else to do.  Zero
+   means the default is an error.  */
+static const yytype_uint8 yydefact[] =
+{
+       0,   111,    92,    93,    94,    95,    96,   141,   139,    98,
+      99,   100,   101,   104,   105,   102,   103,   138,   140,    97,
+     106,   107,   108,   115,   116,     0,   234,     0,    80,    82,
+     109,     0,   110,    84,    86,     0,   231,   233,   133,     0,
+     144,     0,   157,    78,     0,    88,    90,   143,     0,    81,
+      83,   114,     0,    85,    87,     1,   232,     0,   136,     0,
+     134,     0,   161,   159,   158,     0,    79,     0,     0,   237,
+       0,   236,     0,     0,     0,   142,     0,   121,     0,   117,
+       0,   123,     0,     0,   129,     0,   145,   162,   160,    89,
+      90,     2,     3,     4,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   209,
+      24,    25,    26,    27,    28,    29,   215,     6,    18,    30,
+       0,    32,    36,    39,    42,    47,    50,    52,    54,    56,
+      58,    60,    62,    75,     0,   213,   214,   200,   201,     0,
+     211,   202,   203,   204,   205,     2,     0,   188,    91,   238,
+     235,   170,   156,   169,     0,   163,   165,     0,     0,   153,
+      25,     0,     0,     0,   120,   113,   118,     0,     0,   124,
+     126,   122,   130,     0,    30,    77,   137,   131,   135,     0,
+       0,    22,     0,    19,    20,     0,     0,     0,     0,     0,
+       0,     0,     0,   227,   228,   229,     0,     0,   172,     0,
+       0,    12,    13,     0,     0,     0,    65,    66,    67,    68,
+      69,    70,    71,    72,    73,    74,    64,     0,    21,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   216,
+     210,   212,     0,     0,   191,     0,     0,     0,   196,     0,
+       0,   167,   174,   168,   175,   154,     0,   155,     0,     0,
+     152,   148,     0,   147,    25,     0,   112,   127,     0,   119,
+       0,   132,   206,     0,     0,     0,   208,     0,     0,     0,
+       0,     0,     0,   226,   230,     5,     0,   174,   173,     0,
+      11,     8,     0,    16,     0,    10,    63,    33,    34,    35,
+      37,    38,    40,    41,    45,    46,    43,    44,    48,    49,
+      51,    53,    55,    57,    59,     0,    76,     0,   199,   189,
+       0,   192,   195,   197,   184,     0,     0,   178,    25,     0,
+     176,     0,     0,   164,   166,   171,     0,     0,   151,   146,
+     125,   128,    23,     0,   207,     0,     0,     0,     0,     0,
+       0,     0,    31,     9,     0,     7,     0,   198,   190,   193,
+       0,   185,   177,   182,   179,   186,     0,   180,    25,     0,
+     149,   150,   217,   219,   220,     0,     0,     0,     0,     0,
+       0,    17,    61,   194,   187,   183,   181,     0,     0,   224,
+       0,   222,     0,    14,     0,   218,   221,   225,   223,    15
+};
+
+/* YYPGOTO[NTERM-NUM].  */
+static const yytype_int16 yypgoto[] =
+{
+    -309,  -309,  -309,  -309,   -20,  -309,  -111,    78,    91,    51,
+      75,   156,   157,   171,   172,   174,  -309,   -80,   -67,  -309,
+     -76,   -89,   -25,     0,  -309,   341,  -309,   -37,  -309,  -309,
+     332,   -58,   -59,  -309,   141,  -309,   354,   -74,   233,  -309,
+     -22,   -35,   -26,   -64,   -69,  -309,   160,  -309,    81,  -128,
+    -228,   -66,    61,  -308,  -309,   167,   -88,  -309,   -19,  -309,
+     278,  -185,  -309,  -309,  -309,  -309,   383,  -309,  -309
+};
+
+/* YYDEFGOTO[NTERM-NUM].  */
+static const yytype_int16 yydefgoto[] =
+{
+       0,   117,   118,   292,   119,   120,   121,   122,   123,   124,
+     125,   126,   127,   128,   129,   130,   131,   132,   133,   217,
+     134,   176,    26,    70,    44,    45,    28,    29,    30,    31,
+      78,    79,    80,   168,   169,    32,    59,    60,    33,    34,
+      61,    47,    48,    64,   325,   155,   156,   157,   199,   326,
+     254,   244,   245,   246,   247,   248,   136,   137,   138,   139,
+     140,   141,   142,   143,   144,    35,    36,    37,    72
+};
+
+/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
+   positive, shift that token.  If negative, reduce the rule whose
+   number is the opposite.  If YYTABLE_NINF, syntax error.  */
+static const yytype_int16 yytable[] =
+{
+      27,   147,   148,   175,   154,    46,   282,   161,   185,   218,
+     162,   178,   360,    75,   190,    77,    63,   175,   164,    58,
+     166,    69,   171,    58,   330,   253,    40,    71,    49,    50,
+      40,   196,   197,    53,    54,    27,   222,   223,    88,    77,
+      77,    77,   135,    90,    77,    65,   238,   149,    90,   198,
+      38,    51,    40,   150,   236,    57,   238,    40,   170,   330,
+     356,    66,    40,   174,   268,   238,    58,    40,   226,   227,
+     288,    77,   239,   153,   181,   183,   184,   174,   267,   147,
+     269,   284,   200,   201,   202,    76,   360,   175,   177,    41,
+      83,   272,   271,    41,   259,   265,   349,   350,   276,   178,
+     174,   257,    42,    68,   197,   166,   197,   258,   297,   298,
+     299,   277,   278,   279,   135,   249,    43,   250,    39,    52,
+      41,   198,   237,   198,    42,    41,    77,   252,   294,    42,
+     249,   251,   250,    73,    42,    74,   293,   228,   229,     8,
+     203,   167,   204,    77,   205,    77,     8,   174,    17,    18,
+     296,    86,   285,   317,   345,    17,    18,   242,   238,   243,
+     238,   315,   175,   145,    92,    93,   281,    94,   346,    95,
+      96,   316,   287,   286,   238,   250,   187,   322,   352,   147,
+     321,   341,    42,   329,   179,   347,    42,   344,   219,   186,
+     175,   238,   336,   220,   221,   337,   331,   188,   332,   174,
+     174,   174,   174,   174,   174,   174,   174,   174,   174,   174,
+     174,   174,   174,   174,   174,   174,   174,    75,   353,   388,
+     192,   390,   174,   252,   354,   238,   108,   238,   242,   189,
+     243,   146,   358,   191,   110,   111,   112,   113,   114,   115,
+     355,   392,   193,   286,   238,   250,   170,   238,   194,   153,
+     174,    84,    85,   147,   359,   232,   153,   372,   373,   374,
+     287,   273,   366,   274,   233,   369,   172,   173,   234,   174,
+     224,   225,   375,   377,   379,    62,   382,   304,   305,   306,
+     307,   230,   231,   255,   147,    81,   153,   381,   389,   235,
+     391,   319,   320,   147,   383,   393,   394,    87,   256,   395,
+     300,   301,   397,   280,   398,   308,   309,    62,   260,    81,
+      81,    81,   261,   270,    81,   302,   303,   275,   283,   289,
+       1,   290,   295,   318,   335,   338,   339,   147,   359,   342,
+     343,   153,   351,   348,   357,   361,   174,   362,     1,   387,
+     363,    81,   364,     2,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,     8,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+      21,    22,    23,    24,    25,    67,   370,   396,   310,   384,
+     311,    62,   371,   385,   386,    87,    81,    91,    92,    93,
+       1,    94,    68,    95,    96,   312,    89,   313,   163,   340,
+     314,    82,   380,    81,   323,    81,   334,   241,    56,     0,
+       0,     0,     0,     2,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,     0,    97,    98,
+      99,     0,   100,   101,   102,   103,   104,   105,   106,   107,
+     108,     0,     0,     0,     0,    67,   109,     0,   110,   111,
+     112,   113,   114,   115,    91,    92,    93,     1,    94,     0,
+      95,    96,     0,   116,     0,     0,     0,     0,     0,     0,
+       0,     0,    87,     0,     0,     0,     0,     0,     0,     0,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,     0,    97,    98,    99,     0,   100,
+     101,   102,   103,   104,   105,   106,   107,   108,     0,     0,
+       0,     0,    67,   240,     0,   110,   111,   112,   113,   114,
+     115,   145,    92,    93,     1,    94,     0,    95,    96,     0,
+     116,     0,     0,     0,     0,     0,     0,     0,     0,   145,
+      92,    93,     0,    94,     0,    95,    96,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    91,    92,    93,     0,    94,     0,    95,    96,     0,
+       0,     0,     0,     0,   108,     0,     0,     0,     0,     0,
+       0,     0,   110,   111,   112,   113,   114,   115,     0,   145,
+      92,    93,   108,    94,     0,    95,    96,   116,     0,     0,
+     110,   111,   112,   113,   114,   115,     0,     0,     0,     0,
+       0,     0,    97,    98,    99,   195,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,     0,     0,     0,     0,    67,
+       0,     0,   110,   111,   112,   113,   114,   115,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   116,     0,     0,
+       0,     0,   108,     0,     0,     0,     0,     0,     0,     0,
+     110,   111,   112,   113,   114,   115,   145,    92,    93,     1,
+      94,     0,    95,    96,     0,   116,     0,   206,   207,   208,
+     209,   210,   211,   212,   213,   214,   215,     0,     0,   145,
+      92,    93,     0,    94,     0,    95,    96,     0,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,     0,   158,     0,     0,
+       0,     8,     0,     0,     0,     0,     0,     0,     0,   108,
+      17,    18,     0,     0,     0,     0,     0,   110,   111,   112,
+     113,   114,   115,   145,    92,    93,   216,    94,     0,    95,
+      96,     0,   108,     0,     0,   159,     0,     0,     0,     0,
+     110,   160,   112,   113,   114,   115,   145,    92,    93,     0,
+      94,   262,    95,    96,     0,     8,     0,     0,     0,     0,
+       0,     0,     0,     0,    17,    18,   145,    92,    93,     0,
+      94,     0,    95,    96,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   108,     0,     0,   263,
+       0,     0,     0,     0,   110,   264,   112,   113,   114,   115,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   108,
+       0,   242,     0,   243,   146,   399,     0,   110,   111,   112,
+     113,   114,   115,     0,     0,     0,     0,     0,     0,   108,
+       0,   242,     0,   243,   146,     0,     0,   110,   111,   112,
+     113,   114,   115,   145,    92,    93,     0,    94,     0,    95,
+      96,     0,     0,     0,     0,     0,     0,   145,    92,    93,
+       0,    94,     0,    95,    96,     0,     0,     0,     0,     0,
+       0,     0,   145,    92,    93,     8,    94,     0,    95,    96,
+       0,     0,     0,     0,    17,    18,   145,    92,    93,     0,
+      94,     0,    95,    96,     0,     0,     0,     0,     0,     0,
+       0,   145,    92,    93,     0,    94,   108,    95,    96,     0,
+       0,     0,     0,     0,   110,   111,   112,   113,   114,   115,
+     108,     0,     0,     0,     0,   146,     0,     0,   110,   111,
+     112,   113,   114,   115,     0,   108,   291,     0,     0,     0,
+       0,     0,     0,   110,   111,   112,   113,   114,   115,   108,
+       0,     0,   327,     0,     0,     0,     0,   110,   328,   112,
+     113,   114,   115,     0,   108,     0,     0,     0,     0,   351,
+       0,     0,   110,   111,   112,   113,   114,   115,   145,    92,
+      93,     0,    94,     0,    95,    96,     0,     0,     0,     0,
+       0,     0,   145,    92,    93,     0,    94,     0,    95,    96,
+       0,     0,     0,     0,     0,     0,   145,    92,    93,     0,
+      94,     0,    95,    96,     0,     0,     0,     0,     0,     0,
+     145,    92,    93,     0,    94,     0,    95,    96,     0,     0,
+       0,     0,     0,     0,     0,     0,   145,    92,    93,     0,
+      94,   108,    95,    96,   367,     0,     0,     0,     0,   110,
+     368,   112,   113,   114,   115,   108,   376,     0,     0,     0,
+       0,     0,     0,   110,   111,   112,   113,   114,   115,   108,
+     378,     0,     0,     0,     0,     0,     0,   110,   111,   112,
+     113,   114,   115,   108,     0,     0,     0,     0,     0,     0,
+       0,   110,   111,   112,   113,   114,   115,    40,     0,   180,
+       1,     0,     0,     0,     0,     0,     0,   110,   111,   112,
+     113,   114,   115,   145,    92,    93,     0,    94,     0,    95,
+      96,     0,     0,     2,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     249,   324,   250,     0,     0,     0,     0,     1,     0,    42,
+       0,     0,     0,     0,     0,     0,   182,     0,     0,     0,
+       0,     0,     0,     0,   110,   111,   112,   113,   114,   115,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,     1,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   286,   324,   250,
+       0,     0,     1,     0,     0,     0,    42,     0,     0,     0,
+       0,     0,     0,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    21,    22,    23,    24,    25,     1,
+     165,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   266,     0,
+       0,     0,     2,     3,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,   151,     0,     0,     1,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    67,     0,     0,     0,     0,     0,
+       0,     0,     2,     3,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    21,    22,    23,    24,    25,     1,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     152,     0,     0,     0,     0,     0,     0,     0,     0,     2,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    25,    55,     0,     0,     0,     0,     0,     0,
+       1,     0,     0,     0,     0,     0,     0,   365,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     2,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,     1,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,   333,     1,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     2,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25
+};
+
+static const yytype_int16 yycheck[] =
+{
+       0,    68,    68,    83,    73,    27,   191,    74,    97,   120,
+      74,    85,   320,    48,   102,    52,    42,    97,    77,     4,
+      78,    46,    81,     4,   252,   153,     4,    46,    28,    29,
+       4,   107,   108,    33,    34,    35,    77,    78,    64,    76,
+      77,    78,    67,    65,    81,    74,    74,    72,    70,   108,
+       4,     4,     4,    72,    19,    72,    74,     4,    80,   287,
+      88,    90,     4,    83,    74,    74,     4,     4,    14,    15,
+     198,   108,    90,    73,    94,    95,    96,    97,   167,   146,
+      90,    90,     9,    10,    11,    72,   394,   167,    73,    67,
+      89,   179,    73,    67,   158,   162,   281,   282,   186,   173,
+     120,    68,    76,    89,   180,   163,   182,    74,   219,   220,
+     221,   187,   188,   189,   139,    67,    90,    69,    72,    72,
+      67,   180,    87,   182,    76,    67,   163,   153,   204,    76,
+      67,   153,    69,    67,    76,    69,   203,    83,    84,    36,
+      67,    88,    69,   180,    71,   182,    36,   167,    45,    46,
+     217,    68,    68,   242,    68,    45,    46,    69,    74,    71,
+      74,   237,   242,     4,     5,     6,   191,     8,    68,    10,
+      11,   238,   198,    67,    74,    69,    67,    89,   289,   246,
+     246,   270,    76,   250,    88,    68,    76,   275,    76,    88,
+     270,    74,   259,    81,    82,   262,    67,    67,    69,   219,
+     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
+     230,   231,   232,   233,   234,   235,   236,   252,    68,    68,
+       4,    68,   242,   249,    74,    74,    67,    74,    69,    67,
+      71,    72,    73,    67,    75,    76,    77,    78,    79,    80,
+      70,    68,    90,    67,    74,    69,   268,    74,    90,   249,
+     270,    73,    74,   320,   320,    75,   256,   345,   346,   347,
+     286,   180,   331,   182,    85,   332,    73,    74,    86,   289,
+      12,    13,   348,   349,   350,    42,   356,   226,   227,   228,
+     229,    16,    17,    68,   351,    52,   286,   354,   376,    18,
+     378,    73,    74,   360,   360,    73,    74,    64,    74,   387,
+     222,   223,   390,    60,   392,   230,   231,    74,    70,    76,
+      77,    78,    70,    88,    81,   224,   225,    88,    90,    68,
+       7,     4,     4,     4,     4,    70,    70,   394,   394,    68,
+      68,   331,    72,    67,    70,    68,   356,    68,     7,    58,
+      70,   108,    70,    30,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,    49,    50,    51,    52,    53,    36,    37,    38,
+      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+      49,    50,    51,    52,    53,    72,    70,    90,   232,    68,
+     233,   158,    70,    70,    70,   162,   163,     4,     5,     6,
+       7,     8,    89,    10,    11,   234,    65,   235,    76,   268,
+     236,    57,   351,   180,   247,   182,   256,   139,    35,    -1,
+      -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,    49,    50,    51,    52,    53,    -1,    55,    56,
+      57,    -1,    59,    60,    61,    62,    63,    64,    65,    66,
+      67,    -1,    -1,    -1,    -1,    72,    73,    -1,    75,    76,
+      77,    78,    79,    80,     4,     5,     6,     7,     8,    -1,
+      10,    11,    -1,    90,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   259,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53,    -1,    55,    56,    57,    -1,    59,
+      60,    61,    62,    63,    64,    65,    66,    67,    -1,    -1,
+      -1,    -1,    72,    73,    -1,    75,    76,    77,    78,    79,
+      80,     4,     5,     6,     7,     8,    -1,    10,    11,    -1,
+      90,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     4,
+       5,     6,    -1,     8,    -1,    10,    11,    30,    31,    32,
+      33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
+      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
+      53,     4,     5,     6,    -1,     8,    -1,    10,    11,    -1,
+      -1,    -1,    -1,    -1,    67,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    75,    76,    77,    78,    79,    80,    -1,     4,
+       5,     6,    67,     8,    -1,    10,    11,    90,    -1,    -1,
+      75,    76,    77,    78,    79,    80,    -1,    -1,    -1,    -1,
+      -1,    -1,    55,    56,    57,    90,    59,    60,    61,    62,
+      63,    64,    65,    66,    67,    -1,    -1,    -1,    -1,    72,
+      -1,    -1,    75,    76,    77,    78,    79,    80,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,
+      -1,    -1,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      75,    76,    77,    78,    79,    80,     4,     5,     6,     7,
+       8,    -1,    10,    11,    -1,    90,    -1,    20,    21,    22,
+      23,    24,    25,    26,    27,    28,    29,    -1,    -1,     4,
+       5,     6,    -1,     8,    -1,    10,    11,    -1,    36,    37,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    50,    51,    52,    53,    -1,    32,    -1,    -1,
+      -1,    36,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    67,
+      45,    46,    -1,    -1,    -1,    -1,    -1,    75,    76,    77,
+      78,    79,    80,     4,     5,     6,    89,     8,    -1,    10,
+      11,    -1,    67,    -1,    -1,    70,    -1,    -1,    -1,    -1,
+      75,    76,    77,    78,    79,    80,     4,     5,     6,    -1,
+       8,    32,    10,    11,    -1,    36,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    45,    46,     4,     5,     6,    -1,
+       8,    -1,    10,    11,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    -1,    70,
+      -1,    -1,    -1,    -1,    75,    76,    77,    78,    79,    80,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    67,
+      -1,    69,    -1,    71,    72,    73,    -1,    75,    76,    77,
+      78,    79,    80,    -1,    -1,    -1,    -1,    -1,    -1,    67,
+      -1,    69,    -1,    71,    72,    -1,    -1,    75,    76,    77,
+      78,    79,    80,     4,     5,     6,    -1,     8,    -1,    10,
+      11,    -1,    -1,    -1,    -1,    -1,    -1,     4,     5,     6,
+      -1,     8,    -1,    10,    11,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,     4,     5,     6,    36,     8,    -1,    10,    11,
+      -1,    -1,    -1,    -1,    45,    46,     4,     5,     6,    -1,
+       8,    -1,    10,    11,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,     4,     5,     6,    -1,     8,    67,    10,    11,    -1,
+      -1,    -1,    -1,    -1,    75,    76,    77,    78,    79,    80,
+      67,    -1,    -1,    -1,    -1,    72,    -1,    -1,    75,    76,
+      77,    78,    79,    80,    -1,    67,    68,    -1,    -1,    -1,
+      -1,    -1,    -1,    75,    76,    77,    78,    79,    80,    67,
+      -1,    -1,    70,    -1,    -1,    -1,    -1,    75,    76,    77,
+      78,    79,    80,    -1,    67,    -1,    -1,    -1,    -1,    72,
+      -1,    -1,    75,    76,    77,    78,    79,    80,     4,     5,
+       6,    -1,     8,    -1,    10,    11,    -1,    -1,    -1,    -1,
+      -1,    -1,     4,     5,     6,    -1,     8,    -1,    10,    11,
+      -1,    -1,    -1,    -1,    -1,    -1,     4,     5,     6,    -1,
+       8,    -1,    10,    11,    -1,    -1,    -1,    -1,    -1,    -1,
+       4,     5,     6,    -1,     8,    -1,    10,    11,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,     4,     5,     6,    -1,
+       8,    67,    10,    11,    70,    -1,    -1,    -1,    -1,    75,
+      76,    77,    78,    79,    80,    67,    68,    -1,    -1,    -1,
+      -1,    -1,    -1,    75,    76,    77,    78,    79,    80,    67,
+      68,    -1,    -1,    -1,    -1,    -1,    -1,    75,    76,    77,
+      78,    79,    80,    67,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    75,    76,    77,    78,    79,    80,     4,    -1,    67,
+       7,    -1,    -1,    -1,    -1,    -1,    -1,    75,    76,    77,
+      78,    79,    80,     4,     5,     6,    -1,     8,    -1,    10,
+      11,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,    49,    50,    51,    52,    53,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      67,    68,    69,    -1,    -1,    -1,    -1,     7,    -1,    76,
+      -1,    -1,    -1,    -1,    -1,    -1,    67,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    75,    76,    77,    78,    79,    80,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53,     7,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    67,    68,    69,
+      -1,    -1,     7,    -1,    -1,    -1,    76,    -1,    -1,    -1,
+      -1,    -1,    -1,    36,    37,    38,    39,    40,    41,    42,
+      43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
+      53,    36,    37,    38,    39,    40,    41,    42,    43,    44,
+      45,    46,    47,    48,    49,    50,    51,    52,    53,     7,
+      73,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    73,    -1,
+      -1,    -1,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    50,    51,    52,    53,     4,    -1,    -1,     7,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    72,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    50,    51,    52,    53,     7,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      68,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    30,
+      31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
+      41,    42,    43,    44,    45,    46,    47,    48,    49,    50,
+      51,    52,    53,     0,    -1,    -1,    -1,    -1,    -1,    -1,
+       7,    -1,    -1,    -1,    -1,    -1,    -1,    68,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,    49,    50,    51,    52,    53,     7,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53,    54,     7,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      52,    53
+};
+
+/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
+   state STATE-NUM.  */
+static const yytype_uint8 yystos[] =
+{
+       0,     7,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    50,    51,    52,    53,   113,   114,   117,   118,
+     119,   120,   126,   129,   130,   156,   157,   158,     4,    72,
+       4,    67,    76,    90,   115,   116,   131,   132,   133,   114,
+     114,     4,    72,   114,   114,     0,   157,    72,     4,   127,
+     128,   131,   129,   133,   134,    74,    90,    72,    89,   113,
+     114,   149,   159,    67,    69,   132,    72,   118,   121,   122,
+     123,   129,   127,    89,    73,    74,    68,   129,   133,   116,
+     131,     4,     5,     6,     8,    10,    11,    55,    56,    57,
+      59,    60,    61,    62,    63,    64,    65,    66,    67,    73,
+      75,    76,    77,    78,    79,    80,    90,    92,    93,    95,
+      96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
+     106,   107,   108,   109,   111,   113,   147,   148,   149,   150,
+     151,   152,   153,   154,   155,     4,    72,   109,   142,   113,
+     149,     4,    68,   114,   135,   136,   137,   138,    32,    70,
+      76,   109,   134,   121,   123,    73,   122,    88,   124,   125,
+     131,   123,    73,    74,    95,   108,   112,    73,   128,    88,
+      67,    95,    67,    95,    95,   112,    88,    67,    67,    67,
+     147,    67,     4,    90,    90,    90,   111,   111,   123,   139,
+       9,    10,    11,    67,    69,    71,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    89,   110,    97,    76,
+      81,    82,    77,    78,    12,    13,    14,    15,    83,    84,
+      16,    17,    75,    85,    86,    18,    19,    87,    74,    90,
+      73,   151,    69,    71,   142,   143,   144,   145,   146,    67,
+      69,   131,   133,   140,   141,    68,    74,    68,    74,   134,
+      70,    70,    32,    70,    76,   109,    73,   112,    74,    90,
+      88,    73,   147,   139,   139,    88,   147,   111,   111,   111,
+      60,   113,   152,    90,    90,    68,    67,   133,   140,    68,
+       4,    68,    94,   109,   111,     4,   109,    97,    97,    97,
+      98,    98,    99,    99,   100,   100,   100,   100,   101,   101,
+     102,   103,   104,   105,   106,   111,   109,   112,     4,    73,
+      74,   142,    89,   146,    68,   135,   140,    70,    76,   109,
+     141,    67,    69,    54,   137,     4,   109,   109,    70,    70,
+     125,   112,    68,    68,   147,    68,    68,    68,    67,   152,
+     152,    72,    97,    68,    74,    70,    88,    70,    73,   142,
+     144,    68,    68,    70,    70,    68,   135,    70,    76,   109,
+      70,    70,   147,   147,   147,   111,    68,   111,    68,   111,
+     143,   109,   108,   142,    68,    70,    70,    58,    68,   147,
+      68,   147,    68,    73,    74,   147,    90,   147,   147,    73
+};
+
+/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM.  */
+static const yytype_uint8 yyr1[] =
+{
+       0,    91,    92,    92,    92,    92,    93,    93,    93,    93,
+      93,    93,    93,    93,    93,    93,    94,    94,    95,    95,
+      95,    95,    95,    95,    96,    96,    96,    96,    96,    96,
+      97,    97,    98,    98,    98,    98,    99,    99,    99,   100,
+     100,   100,   101,   101,   101,   101,   101,   102,   102,   102,
+     103,   103,   104,   104,   105,   105,   106,   106,   107,   107,
+     108,   108,   109,   109,   110,   110,   110,   110,   110,   110,
+     110,   110,   110,   110,   110,   111,   111,   112,   113,   113,
+     114,   114,   114,   114,   114,   114,   114,   114,   115,   115,
+     116,   116,   117,   117,   117,   117,   117,   118,   118,   118,
+     118,   118,   118,   118,   118,   118,   118,   118,   118,   118,
+     118,   118,   119,   119,   119,   120,   120,   121,   121,   122,
+     123,   123,   123,   123,   124,   124,   125,   125,   125,   126,
+     126,   126,   126,   126,   127,   127,   128,   128,   129,   129,
+     129,   130,   131,   131,   132,   132,   132,   132,   132,   132,
+     132,   132,   132,   132,   132,   132,   132,   133,   133,   133,
+     133,   134,   134,   135,   135,   136,   136,   137,   137,   137,
+     138,   138,   139,   139,   140,   140,   140,   141,   141,   141,
+     141,   141,   141,   141,   141,   141,   141,   141,   142,   142,
+     142,   143,   143,   143,   143,   144,   145,   145,   146,   146,
+     147,   147,   147,   147,   147,   147,   148,   148,   148,   149,
+     149,   150,   150,   151,   151,   152,   152,   153,   153,   153,
+     154,   154,   154,   154,   154,   154,   155,   155,   155,   155,
+     155,   156,   156,   157,   157,   158,   158,   159,   159
+};
+
+/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM.  */
+static const yytype_int8 yyr2[] =
+{
+       0,     2,     1,     1,     1,     3,     1,     4,     3,     4,
+       3,     3,     2,     2,     6,     7,     1,     3,     1,     2,
+       2,     2,     2,     4,     1,     1,     1,     1,     1,     1,
+       1,     4,     1,     3,     3,     3,     1,     3,     3,     1,
+       3,     3,     1,     3,     3,     3,     3,     1,     3,     3,
+       1,     3,     1,     3,     1,     3,     1,     3,     1,     3,
+       1,     5,     1,     3,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     3,     1,     2,     3,
+       1,     2,     1,     2,     1,     2,     1,     2,     1,     3,
+       1,     3,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     5,     4,     2,     1,     1,     1,     2,     3,
+       2,     1,     2,     1,     1,     3,     1,     2,     3,     4,
+       5,     5,     6,     2,     1,     3,     1,     3,     1,     1,
+       1,     1,     2,     1,     1,     3,     5,     4,     4,     6,
+       6,     5,     4,     3,     4,     4,     3,     1,     2,     2,
+       3,     1,     2,     1,     3,     1,     3,     2,     2,     1,
+       1,     3,     1,     2,     1,     1,     2,     3,     2,     3,
+       3,     4,     3,     4,     2,     3,     3,     4,     1,     3,
+       4,     1,     2,     3,     4,     2,     1,     2,     3,     2,
+       1,     1,     1,     1,     1,     1,     3,     4,     3,     2,
+       3,     1,     2,     1,     1,     1,     2,     5,     7,     5,
+       5,     7,     6,     7,     6,     7,     3,     2,     2,     2,
+       3,     1,     2,     1,     1,     4,     3,     1,     2
+};
+
+
+enum { YYENOMEM = -2 };
+
+#define yyerrok         (yyerrstatus = 0)
+#define yyclearin       (yychar = YYEMPTY)
+
+#define YYACCEPT        goto yyacceptlab
+#define YYABORT         goto yyabortlab
+#define YYERROR         goto yyerrorlab
+#define YYNOMEM         goto yyexhaustedlab
+
+
+#define YYRECOVERING()  (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value)                                    \
+  do                                                              \
+    if (yychar == YYEMPTY)                                        \
+      {                                                           \
+        yychar = (Token);                                         \
+        yylval = (Value);                                         \
+        YYPOPSTACK (yylen);                                       \
+        yystate = *yyssp;                                         \
+        goto yybackup;                                            \
+      }                                                           \
+    else                                                          \
+      {                                                           \
+        yyerror (YY_("syntax error: cannot back up")); \
+        YYERROR;                                                  \
+      }                                                           \
+  while (0)
+
+/* Backward compatibility with an undocumented macro.
+   Use YYerror or YYUNDEF. */
+#define YYERRCODE YYUNDEF
+
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
+    do                                                                  \
+      if (N)                                                            \
+        {                                                               \
+          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
+          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
+          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
+          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
+        }                                                               \
+      else                                                              \
+        {                                                               \
+          (Current).first_line   = (Current).last_line   =              \
+            YYRHSLOC (Rhs, 0).last_line;                                \
+          (Current).first_column = (Current).last_column =              \
+            YYRHSLOC (Rhs, 0).last_column;                              \
+        }                                                               \
+    while (0)
+#endif
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
+
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)                        \
+do {                                            \
+  if (yydebug)                                  \
+    YYFPRINTF Args;                             \
+} while (0)
+
+
+/* YYLOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+# ifndef YYLOCATION_PRINT
+
+#  if defined YY_LOCATION_PRINT
+
+   /* Temporary convenience wrapper in case some people defined the
+      undocumented and private YY_LOCATION_PRINT macros.  */
+#   define YYLOCATION_PRINT(File, Loc)  YY_LOCATION_PRINT(File, *(Loc))
+
+#  elif defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+
+/* Print *YYLOCP on YYO.  Private, do not rely on its existence. */
+
+YY_ATTRIBUTE_UNUSED
+static int
+yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
+{
+  int res = 0;
+  int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
+  if (0 <= yylocp->first_line)
+    {
+      res += YYFPRINTF (yyo, "%d", yylocp->first_line);
+      if (0 <= yylocp->first_column)
+        res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
+    }
+  if (0 <= yylocp->last_line)
+    {
+      if (yylocp->first_line < yylocp->last_line)
+        {
+          res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
+          if (0 <= end_col)
+            res += YYFPRINTF (yyo, ".%d", end_col);
+        }
+      else if (0 <= end_col && yylocp->first_column < end_col)
+        res += YYFPRINTF (yyo, "-%d", end_col);
+    }
+  return res;
+}
+
+#   define YYLOCATION_PRINT  yy_location_print_
+
+    /* Temporary convenience wrapper in case some people defined the
+       undocumented and private YY_LOCATION_PRINT macros.  */
+#   define YY_LOCATION_PRINT(File, Loc)  YYLOCATION_PRINT(File, &(Loc))
+
+#  else
+
+#   define YYLOCATION_PRINT(File, Loc) ((void) 0)
+    /* Temporary convenience wrapper in case some people defined the
+       undocumented and private YY_LOCATION_PRINT macros.  */
+#   define YY_LOCATION_PRINT  YYLOCATION_PRINT
+
+#  endif
+# endif /* !defined YYLOCATION_PRINT */
+
+
+# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)                    \
+do {                                                                      \
+  if (yydebug)                                                            \
+    {                                                                     \
+      YYFPRINTF (stderr, "%s ", Title);                                   \
+      yy_symbol_print (stderr,                                            \
+                  Kind, Value, Location); \
+      YYFPRINTF (stderr, "\n");                                           \
+    }                                                                     \
+} while (0)
+
+
+/*-----------------------------------.
+| Print this symbol's value on YYO.  |
+`-----------------------------------*/
+
+static void
+yy_symbol_value_print (FILE *yyo,
+                       yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
+{
+  FILE *yyoutput = yyo;
+  YY_USE (yyoutput);
+  YY_USE (yylocationp);
+  if (!yyvaluep)
+    return;
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  YY_USE (yykind);
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+/*---------------------------.
+| Print this symbol on YYO.  |
+`---------------------------*/
+
+static void
+yy_symbol_print (FILE *yyo,
+                 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
+{
+  YYFPRINTF (yyo, "%s %s (",
+             yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
+
+  YYLOCATION_PRINT (yyo, yylocationp);
+  YYFPRINTF (yyo, ": ");
+  yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp);
+  YYFPRINTF (yyo, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+static void
+yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (; yybottom <= yytop; yybottom++)
+    {
+      int yybot = *yybottom;
+      YYFPRINTF (stderr, " %d", yybot);
+    }
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)                            \
+do {                                                            \
+  if (yydebug)                                                  \
+    yy_stack_print ((Bottom), (Top));                           \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+static void
+yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp,
+                 int yyrule)
+{
+  int yylno = yyrline[yyrule];
+  int yynrhs = yyr2[yyrule];
+  int yyi;
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
+             yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr,
+                       YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
+                       &yyvsp[(yyi + 1) - (yynrhs)],
+                       &(yylsp[(yyi + 1) - (yynrhs)]));
+      YYFPRINTF (stderr, "\n");
+    }
+}
+
+# define YY_REDUCE_PRINT(Rule)          \
+do {                                    \
+  if (yydebug)                          \
+    yy_reduce_print (yyssp, yyvsp, yylsp, Rule); \
+} while (0)
+
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args) ((void) 0)
+# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
+#ifndef YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+
+
+
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+static void
+yydestruct (const char *yymsg,
+            yysymbol_kind_t yykind, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
+{
+  YY_USE (yyvaluep);
+  YY_USE (yylocationp);
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  YY_USE (yykind);
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+/* Lookahead token kind.  */
+int yychar;
+
+/* The semantic value of the lookahead symbol.  */
+YYSTYPE yylval;
+/* Location data for the lookahead symbol.  */
+YYLTYPE yylloc
+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+  = { 1, 1, 1, 1 }
+# endif
+;
+/* Number of syntax errors so far.  */
+int yynerrs;
+
+
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+int
+yyparse (void)
+{
+    yy_state_fast_t yystate = 0;
+    /* Number of tokens to shift before error messages enabled.  */
+    int yyerrstatus = 0;
+
+    /* Refer to the stacks through separate pointers, to allow yyoverflow
+       to reallocate them elsewhere.  */
+
+    /* Their size.  */
+    YYPTRDIFF_T yystacksize = YYINITDEPTH;
+
+    /* The state stack: array, bottom, top.  */
+    yy_state_t yyssa[YYINITDEPTH];
+    yy_state_t *yyss = yyssa;
+    yy_state_t *yyssp = yyss;
+
+    /* The semantic value stack: array, bottom, top.  */
+    YYSTYPE yyvsa[YYINITDEPTH];
+    YYSTYPE *yyvs = yyvsa;
+    YYSTYPE *yyvsp = yyvs;
+
+    /* The location stack: array, bottom, top.  */
+    YYLTYPE yylsa[YYINITDEPTH];
+    YYLTYPE *yyls = yylsa;
+    YYLTYPE *yylsp = yyls;
+
+  int yyn;
+  /* The return value of yyparse.  */
+  int yyresult;
+  /* Lookahead symbol kind.  */
+  yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+  YYLTYPE yyloc;
+
+  /* The locations where the error started and ended.  */
+  YYLTYPE yyerror_range[3];
+
+
+
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
+
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yychar = YYEMPTY; /* Cause a token to be read.  */
+
+  yylsp[0] = yylloc;
+  goto yysetstate;
+
+
+/*------------------------------------------------------------.
+| yynewstate -- push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed.  So pushing a state here evens the stacks.  */
+  yyssp++;
+
+
+/*--------------------------------------------------------------------.
+| yysetstate -- set current state (the top of the stack) to yystate.  |
+`--------------------------------------------------------------------*/
+yysetstate:
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
+  YY_IGNORE_USELESS_CAST_BEGIN
+  *yyssp = YY_CAST (yy_state_t, yystate);
+  YY_IGNORE_USELESS_CAST_END
+  YY_STACK_PRINT (yyss, yyssp);
+
+  if (yyss + yystacksize - 1 <= yyssp)
+#if !defined yyoverflow && !defined YYSTACK_RELOCATE
+    YYNOMEM;
+#else
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYPTRDIFF_T yysize = yyssp - yyss + 1;
+
+# if defined yyoverflow
+      {
+        /* Give user a chance to reallocate the stack.  Use copies of
+           these so that the &'s don't force the real ones into
+           memory.  */
+        yy_state_t *yyss1 = yyss;
+        YYSTYPE *yyvs1 = yyvs;
+        YYLTYPE *yyls1 = yyls;
+
+        /* Each stack pointer address is followed by the size of the
+           data in use in that stack, in bytes.  This used to be a
+           conditional around just the two extra args, but that might
+           be undefined if yyoverflow is a macro.  */
+        yyoverflow (YY_("memory exhausted"),
+                    &yyss1, yysize * YYSIZEOF (*yyssp),
+                    &yyvs1, yysize * YYSIZEOF (*yyvsp),
+                    &yyls1, yysize * YYSIZEOF (*yylsp),
+                    &yystacksize);
+        yyss = yyss1;
+        yyvs = yyvs1;
+        yyls = yyls1;
+      }
+# else /* defined YYSTACK_RELOCATE */
+      /* Extend the stack our own way.  */
+      if (YYMAXDEPTH <= yystacksize)
+        YYNOMEM;
+      yystacksize *= 2;
+      if (YYMAXDEPTH < yystacksize)
+        yystacksize = YYMAXDEPTH;
+
+      {
+        yy_state_t *yyss1 = yyss;
+        union yyalloc *yyptr =
+          YY_CAST (union yyalloc *,
+                   YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
+        if (! yyptr)
+          YYNOMEM;
+        YYSTACK_RELOCATE (yyss_alloc, yyss);
+        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+        YYSTACK_RELOCATE (yyls_alloc, yyls);
+#  undef YYSTACK_RELOCATE
+        if (yyss1 != yyssa)
+          YYSTACK_FREE (yyss1);
+      }
+# endif
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+      yylsp = yyls + yysize - 1;
+
+      YY_IGNORE_USELESS_CAST_BEGIN
+      YYDPRINTF ((stderr, "Stack size increased to %ld\n",
+                  YY_CAST (long, yystacksize)));
+      YY_IGNORE_USELESS_CAST_END
+
+      if (yyss + yystacksize - 1 <= yyssp)
+        YYABORT;
+    }
+#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
+
+
+  if (yystate == YYFINAL)
+    YYACCEPT;
+
+  goto yybackup;
+
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+  /* Do appropriate processing given the current state.  Read a
+     lookahead token if we need one and don't already have one.  */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+  yyn = yypact[yystate];
+  if (yypact_value_is_default (yyn))
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* YYCHAR is either empty, or end-of-input, or a valid lookahead.  */
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token\n"));
+      yychar = yylex ();
+    }
+
+  if (yychar <= YYEOF)
+    {
+      yychar = YYEOF;
+      yytoken = YYSYMBOL_YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else if (yychar == YYerror)
+    {
+      /* The scanner already issued an error message, process directly
+         to error recovery.  But do not keep the error token as
+         lookahead, it is too special and may lead us to an endless
+         loop in error recovery. */
+      yychar = YYUNDEF;
+      yytoken = YYSYMBOL_YYerror;
+      yyerror_range[1] = yylloc;
+      goto yyerrlab1;
+    }
+  else
+    {
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+    }
+
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+    goto yydefault;
+  yyn = yytable[yyn];
+  if (yyn <= 0)
+    {
+      if (yytable_value_is_error (yyn))
+        goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  /* Shift the lookahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+  yystate = yyn;
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+  *++yylsp = yylloc;
+
+  /* Discard the shifted token.  */
+  yychar = YYEMPTY;
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     '$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+  /* Default location. */
+  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
+  yyerror_range[1] = yyloc;
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
+    {
+  case 2: /* primary_expression: IDENTIFIER  */
+#line 144 "mini_c.y"
+                              { (yyval.node) = new_id_node((yyvsp[0].sval), LOC((yylsp[0]))); }
+#line 1902 "mini_c.tab.cpp"
+    break;
+
+  case 3: /* primary_expression: CONSTANT  */
+#line 145 "mini_c.y"
+                              { (yyval.node) = new_const_node((yyvsp[0].sval), LOC((yylsp[0]))); }
+#line 1908 "mini_c.tab.cpp"
+    break;
+
+  case 4: /* primary_expression: STRING_LITERAL  */
+#line 146 "mini_c.y"
+                              { (yyval.node) = new_string_node((yyvsp[0].sval), LOC((yylsp[0]))); }
+#line 1914 "mini_c.tab.cpp"
+    break;
+
+  case 5: /* primary_expression: '(' expression ')'  */
+#line 147 "mini_c.y"
+                              { (yyval.node) = (yyvsp[-1].node); (yyval.node)->loc = LOC((yylsp[0])); }
+#line 1920 "mini_c.tab.cpp"
+    break;
+
+  case 6: /* postfix_expression: primary_expression  */
+#line 151 "mini_c.y"
+                                                                   { (yyval.node) = (yyvsp[0].node); }
+#line 1926 "mini_c.tab.cpp"
+    break;
+
+  case 7: /* postfix_expression: postfix_expression '[' expression ']'  */
+#line 152 "mini_c.y"
+                                                                   { (yyval.node) = new_array_ref_node((yyvsp[-3].node), (yyvsp[-1].node), LOC((yylsp[-2]))); }
+#line 1932 "mini_c.tab.cpp"
+    break;
+
+  case 8: /* postfix_expression: postfix_expression '(' ')'  */
+#line 153 "mini_c.y"
+                                                                   { (yyval.node) = new_func_call_node((yyvsp[-2].node), NULL, LOC((yylsp[-1]))); }
+#line 1938 "mini_c.tab.cpp"
+    break;
+
+  case 9: /* postfix_expression: postfix_expression '(' argument_expression_list ')'  */
+#line 154 "mini_c.y"
+                                                                   { (yyval.node) = new_func_call_node((yyvsp[-3].node), (yyvsp[-1].node), LOC((yylsp[-2]))); }
+#line 1944 "mini_c.tab.cpp"
+    break;
+
+  case 10: /* postfix_expression: postfix_expression '.' IDENTIFIER  */
+#line 155 "mini_c.y"
+                                                                   { (yyval.node) = new_struct_ref_node((yyvsp[-2].node), (yyvsp[0].sval), false, LOC((yylsp[-1]))); }
+#line 1950 "mini_c.tab.cpp"
+    break;
+
+  case 11: /* postfix_expression: postfix_expression PTR_OP IDENTIFIER  */
+#line 156 "mini_c.y"
+                                                                   { (yyval.node) = new_struct_ref_node((yyvsp[-2].node), (yyvsp[0].sval), true, LOC((yylsp[-1]))); }
+#line 1956 "mini_c.tab.cpp"
+    break;
+
+  case 12: /* postfix_expression: postfix_expression INC_OP  */
+#line 157 "mini_c.y"
+                                                                   { (yyval.node) = new_post_inc_node((yyvsp[-1].node), LOC((yylsp[0]))); }
+#line 1962 "mini_c.tab.cpp"
+    break;
+
+  case 13: /* postfix_expression: postfix_expression DEC_OP  */
+#line 158 "mini_c.y"
+                                                                   { (yyval.node) = new_post_dec_node((yyvsp[-1].node), LOC((yylsp[0]))); }
+#line 1968 "mini_c.tab.cpp"
+    break;
+
+  case 14: /* postfix_expression: '(' type_name ')' '{' initializer_list '}'  */
+#line 159 "mini_c.y"
+                                                                   { (yyval.node) = new_compound_literal_node((yyvsp[-4].node), (yyvsp[-1].node), LOC((yylsp[-5]))); }
+#line 1974 "mini_c.tab.cpp"
+    break;
+
+  case 15: /* postfix_expression: '(' type_name ')' '{' initializer_list ',' '}'  */
+#line 160 "mini_c.y"
+                                                                   { (yyval.node) = new_compound_literal_node((yyvsp[-5].node), (yyvsp[-2].node), LOC((yylsp[-6]))); }
+#line 1980 "mini_c.tab.cpp"
+    break;
+
+  case 16: /* argument_expression_list: assignment_expression  */
+#line 165 "mini_c.y"
+                                                                   { (yyval.node) = new_arg_list((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 1986 "mini_c.tab.cpp"
+    break;
+
+  case 17: /* argument_expression_list: argument_expression_list ',' assignment_expression  */
+#line 166 "mini_c.y"
+                                                                   { (yyval.node) = append_arg_list((yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 1992 "mini_c.tab.cpp"
+    break;
+
+  case 18: /* unary_expression: postfix_expression  */
+#line 170 "mini_c.y"
+                                                                   { (yyval.node) = (yyvsp[0].node); }
+#line 1998 "mini_c.tab.cpp"
+    break;
+
+  case 19: /* unary_expression: INC_OP unary_expression  */
+#line 171 "mini_c.y"
+                                                                   { (yyval.node) = new_pre_inc_node((yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2004 "mini_c.tab.cpp"
+    break;
+
+  case 20: /* unary_expression: DEC_OP unary_expression  */
+#line 172 "mini_c.y"
+                                                                   { (yyval.node) = new_pre_dec_node((yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2010 "mini_c.tab.cpp"
+    break;
+
+  case 21: /* unary_expression: unary_operator cast_expression  */
+#line 173 "mini_c.y"
+                                                                   { (yyval.node) = new_unary_op_node((yyvsp[-1].ival), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2016 "mini_c.tab.cpp"
+    break;
+
+  case 22: /* unary_expression: SIZEOF unary_expression  */
+#line 174 "mini_c.y"
+                                                                   { (yyval.node) = new_sizeof_node((yyvsp[0].node), false, LOC((yylsp[-1]))); }
+#line 2022 "mini_c.tab.cpp"
+    break;
+
+  case 23: /* unary_expression: SIZEOF '(' type_name ')'  */
+#line 175 "mini_c.y"
+                                                                   { (yyval.node) = new_sizeof_node((yyvsp[-1].node), true, LOC((yylsp[-3]))); }
+#line 2028 "mini_c.tab.cpp"
+    break;
+
+  case 24: /* unary_operator: '&'  */
+#line 179 "mini_c.y"
+            { (yyval.ival) = op_address; }
+#line 2034 "mini_c.tab.cpp"
+    break;
+
+  case 25: /* unary_operator: '*'  */
+#line 180 "mini_c.y"
+            { (yyval.ival) = op_deref; }
+#line 2040 "mini_c.tab.cpp"
+    break;
+
+  case 26: /* unary_operator: '+'  */
+#line 181 "mini_c.y"
+            { (yyval.ival) = op_unary_plus; }
+#line 2046 "mini_c.tab.cpp"
+    break;
+
+  case 27: /* unary_operator: '-'  */
+#line 182 "mini_c.y"
+            { (yyval.ival) = op_neg; }
+#line 2052 "mini_c.tab.cpp"
+    break;
+
+  case 28: /* unary_operator: '~'  */
+#line 183 "mini_c.y"
+            { (yyval.ival) = op_bitnot; }
+#line 2058 "mini_c.tab.cpp"
+    break;
+
+  case 29: /* unary_operator: '!'  */
+#line 184 "mini_c.y"
+            { (yyval.ival) = op_not; }
+#line 2064 "mini_c.tab.cpp"
+    break;
+
+  case 30: /* cast_expression: unary_expression  */
+#line 189 "mini_c.y"
+                                                                   { (yyval.node) = (yyvsp[0].node); }
+#line 2070 "mini_c.tab.cpp"
+    break;
+
+  case 31: /* cast_expression: '(' type_name ')' cast_expression  */
+#line 190 "mini_c.y"
+                                                                   { (yyval.node) = new_cast_node((yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-3]))); }
+#line 2076 "mini_c.tab.cpp"
+    break;
+
+  case 32: /* multiplicative_expression: cast_expression  */
+#line 194 "mini_c.y"
+                                                                   { (yyval.node) = (yyvsp[0].node); }
+#line 2082 "mini_c.tab.cpp"
+    break;
+
+  case 33: /* multiplicative_expression: multiplicative_expression '*' cast_expression  */
+#line 195 "mini_c.y"
+                                                                   { (yyval.node) = new_binop_node('*', (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2088 "mini_c.tab.cpp"
+    break;
+
+  case 34: /* multiplicative_expression: multiplicative_expression '/' cast_expression  */
+#line 196 "mini_c.y"
+                                                                   { (yyval.node) = new_binop_node('/', (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2094 "mini_c.tab.cpp"
+    break;
+
+  case 35: /* multiplicative_expression: multiplicative_expression '%' cast_expression  */
+#line 197 "mini_c.y"
+                                                                   { (yyval.node) = new_binop_node('%', (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2100 "mini_c.tab.cpp"
+    break;
+
+  case 36: /* additive_expression: multiplicative_expression  */
+#line 202 "mini_c.y"
+                                                                   { (yyval.node) = (yyvsp[0].node); }
+#line 2106 "mini_c.tab.cpp"
+    break;
+
+  case 37: /* additive_expression: additive_expression '+' multiplicative_expression  */
+#line 203 "mini_c.y"
+                                                                   { (yyval.node) = new_binop_node('+', (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2112 "mini_c.tab.cpp"
+    break;
+
+  case 38: /* additive_expression: additive_expression '-' multiplicative_expression  */
+#line 204 "mini_c.y"
+                                                                   { (yyval.node) = new_binop_node('-', (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2118 "mini_c.tab.cpp"
+    break;
+
+  case 39: /* shift_expression: additive_expression  */
+#line 209 "mini_c.y"
+                                                                   { (yyval.node) = (yyvsp[0].node); }
+#line 2124 "mini_c.tab.cpp"
+    break;
+
+  case 40: /* shift_expression: shift_expression LEFT_OP additive_expression  */
+#line 210 "mini_c.y"
+                                                                   { (yyval.node) = new_binop_node(SHL, (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2130 "mini_c.tab.cpp"
+    break;
+
+  case 41: /* shift_expression: shift_expression RIGHT_OP additive_expression  */
+#line 211 "mini_c.y"
+                                                                   { (yyval.node) = new_binop_node(SHR, (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2136 "mini_c.tab.cpp"
+    break;
+
+  case 42: /* relational_expression: shift_expression  */
+#line 216 "mini_c.y"
+                                                                   { (yyval.node) = (yyvsp[0].node); }
+#line 2142 "mini_c.tab.cpp"
+    break;
+
+  case 43: /* relational_expression: relational_expression '<' shift_expression  */
+#line 217 "mini_c.y"
+                                                                   { (yyval.node) = new_binop_node('<', (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2148 "mini_c.tab.cpp"
+    break;
+
+  case 44: /* relational_expression: relational_expression '>' shift_expression  */
+#line 218 "mini_c.y"
+                                                                   { (yyval.node) = new_binop_node('>', (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2154 "mini_c.tab.cpp"
+    break;
+
+  case 45: /* relational_expression: relational_expression LE_OP shift_expression  */
+#line 219 "mini_c.y"
+                                                                   { (yyval.node) = new_binop_node(LE, (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2160 "mini_c.tab.cpp"
+    break;
+
+  case 46: /* relational_expression: relational_expression GE_OP shift_expression  */
+#line 220 "mini_c.y"
+                                                                   { (yyval.node) = new_binop_node(GE, (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2166 "mini_c.tab.cpp"
+    break;
+
+  case 47: /* equality_expression: relational_expression  */
+#line 225 "mini_c.y"
+                                                                   { (yyval.node) = (yyvsp[0].node); }
+#line 2172 "mini_c.tab.cpp"
+    break;
+
+  case 48: /* equality_expression: equality_expression EQ_OP relational_expression  */
+#line 226 "mini_c.y"
+                                                                   { (yyval.node) = new_binop_node(EQ, (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2178 "mini_c.tab.cpp"
+    break;
+
+  case 49: /* equality_expression: equality_expression NE_OP relational_expression  */
+#line 227 "mini_c.y"
+                                                                   { (yyval.node) = new_binop_node(NE, (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2184 "mini_c.tab.cpp"
+    break;
+
+  case 50: /* and_expression: equality_expression  */
+#line 234 "mini_c.y"
+        { (yyval.node) = (yyvsp[0].node); }
+#line 2190 "mini_c.tab.cpp"
+    break;
+
+  case 51: /* and_expression: and_expression '&' equality_expression  */
+#line 236 "mini_c.y"
+        { (yyval.node) = new_binop_node('&', (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2196 "mini_c.tab.cpp"
+    break;
+
+  case 52: /* exclusive_or_expression: and_expression  */
+#line 242 "mini_c.y"
+        { (yyval.node) = (yyvsp[0].node); }
+#line 2202 "mini_c.tab.cpp"
+    break;
+
+  case 53: /* exclusive_or_expression: exclusive_or_expression '^' and_expression  */
+#line 244 "mini_c.y"
+        { (yyval.node) = new_binop_node('^', (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2208 "mini_c.tab.cpp"
+    break;
+
+  case 54: /* inclusive_or_expression: exclusive_or_expression  */
+#line 250 "mini_c.y"
+        { (yyval.node) = (yyvsp[0].node); }
+#line 2214 "mini_c.tab.cpp"
+    break;
+
+  case 55: /* inclusive_or_expression: inclusive_or_expression '|' exclusive_or_expression  */
+#line 252 "mini_c.y"
+        { (yyval.node) = new_binop_node('|', (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2220 "mini_c.tab.cpp"
+    break;
+
+  case 56: /* logical_and_expression: inclusive_or_expression  */
+#line 258 "mini_c.y"
+        { (yyval.node) = (yyvsp[0].node); }
+#line 2226 "mini_c.tab.cpp"
+    break;
+
+  case 57: /* logical_and_expression: logical_and_expression AND_OP inclusive_or_expression  */
+#line 260 "mini_c.y"
+        { (yyval.node) = new_logical_and_node((yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2232 "mini_c.tab.cpp"
+    break;
+
+  case 58: /* logical_or_expression: logical_and_expression  */
+#line 266 "mini_c.y"
+        { (yyval.node) = (yyvsp[0].node); }
+#line 2238 "mini_c.tab.cpp"
+    break;
+
+  case 59: /* logical_or_expression: logical_or_expression OR_OP logical_and_expression  */
+#line 268 "mini_c.y"
+        { (yyval.node) = new_logical_or_node((yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2244 "mini_c.tab.cpp"
+    break;
+
+  case 60: /* conditional_expression: logical_or_expression  */
+#line 274 "mini_c.y"
+        { (yyval.node) = (yyvsp[0].node); }
+#line 2250 "mini_c.tab.cpp"
+    break;
+
+  case 61: /* conditional_expression: logical_or_expression '?' expression ':' conditional_expression  */
+#line 276 "mini_c.y"
+        { (yyval.node) = new_conditional_node((yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-3]))); }
+#line 2256 "mini_c.tab.cpp"
+    break;
+
+  case 62: /* assignment_expression: conditional_expression  */
+#line 282 "mini_c.y"
+        { (yyval.node) = (yyvsp[0].node); }
+#line 2262 "mini_c.tab.cpp"
+    break;
+
+  case 63: /* assignment_expression: unary_expression assignment_operator assignment_expression  */
+#line 284 "mini_c.y"
+        { (yyval.node) = new_assign_node((yyvsp[-2].node), (yyvsp[-1].ival), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2268 "mini_c.tab.cpp"
+    break;
+
+  case 64: /* assignment_operator: '='  */
+#line 289 "mini_c.y"
+                    { (yyval.ival) = op_assign; }
+#line 2274 "mini_c.tab.cpp"
+    break;
+
+  case 65: /* assignment_operator: MUL_ASSIGN  */
+#line 290 "mini_c.y"
+                    { (yyval.ival) = op_mul_assign; }
+#line 2280 "mini_c.tab.cpp"
+    break;
+
+  case 66: /* assignment_operator: DIV_ASSIGN  */
+#line 291 "mini_c.y"
+                    { (yyval.ival) = op_div_assign; }
+#line 2286 "mini_c.tab.cpp"
+    break;
+
+  case 67: /* assignment_operator: MOD_ASSIGN  */
+#line 292 "mini_c.y"
+                    { (yyval.ival) = op_mod_assign; }
+#line 2292 "mini_c.tab.cpp"
+    break;
+
+  case 68: /* assignment_operator: ADD_ASSIGN  */
+#line 293 "mini_c.y"
+                    { (yyval.ival) = op_add_assign; }
+#line 2298 "mini_c.tab.cpp"
+    break;
+
+  case 69: /* assignment_operator: SUB_ASSIGN  */
+#line 294 "mini_c.y"
+                    { (yyval.ival) = op_sub_assign; }
+#line 2304 "mini_c.tab.cpp"
+    break;
+
+  case 70: /* assignment_operator: LEFT_ASSIGN  */
+#line 295 "mini_c.y"
+                    { (yyval.ival) = op_shl_assign; }
+#line 2310 "mini_c.tab.cpp"
+    break;
+
+  case 71: /* assignment_operator: RIGHT_ASSIGN  */
+#line 296 "mini_c.y"
+                    { (yyval.ival) = op_shr_assign; }
+#line 2316 "mini_c.tab.cpp"
+    break;
+
+  case 72: /* assignment_operator: AND_ASSIGN  */
+#line 297 "mini_c.y"
+                    { (yyval.ival) = op_and_assign; }
+#line 2322 "mini_c.tab.cpp"
+    break;
+
+  case 73: /* assignment_operator: XOR_ASSIGN  */
+#line 298 "mini_c.y"
+                    { (yyval.ival) = op_xor_assign; }
+#line 2328 "mini_c.tab.cpp"
+    break;
+
+  case 74: /* assignment_operator: OR_ASSIGN  */
+#line 299 "mini_c.y"
+                    { (yyval.ival) = op_or_assign; }
+#line 2334 "mini_c.tab.cpp"
+    break;
+
+  case 75: /* expression: assignment_expression  */
+#line 304 "mini_c.y"
+        { (yyval.node) = (yyvsp[0].node); }
+#line 2340 "mini_c.tab.cpp"
+    break;
+
+  case 76: /* expression: expression ',' assignment_expression  */
+#line 306 "mini_c.y"
+        { (yyval.node) = new_expr_list((yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2346 "mini_c.tab.cpp"
+    break;
+
+  case 77: /* constant_expression: conditional_expression  */
+#line 312 "mini_c.y"
+        { (yyval.node) = (yyvsp[0].node); }
+#line 2352 "mini_c.tab.cpp"
+    break;
+
+  case 78: /* declaration: declaration_specifiers ';'  */
+#line 318 "mini_c.y"
+        { (yyval.node) = new_decl_stmt((yyvsp[-1].node), LOC((yylsp[0]))); }
+#line 2358 "mini_c.tab.cpp"
+    break;
+
+  case 79: /* declaration: declaration_specifiers init_declarator_list ';'  */
+#line 320 "mini_c.y"
+        { (yyval.node) = new_declaration((yyvsp[-2].node), (yyvsp[-1].node), LOC((yylsp[0]))); }
+#line 2364 "mini_c.tab.cpp"
+    break;
+
+  case 80: /* declaration_specifiers: storage_class_specifier  */
+#line 326 "mini_c.y"
+        { (yyval.node) = new_spec_list((yyvsp[0].ival), LOC((yylsp[0]))); }
+#line 2370 "mini_c.tab.cpp"
+    break;
+
+  case 81: /* declaration_specifiers: storage_class_specifier declaration_specifiers  */
+#line 328 "mini_c.y"
+        { (yyval.node) = append_spec_list((yyvsp[0].node), (yyvsp[-1].ival), LOC((yylsp[-1]))); }
+#line 2376 "mini_c.tab.cpp"
+    break;
+
+  case 82: /* declaration_specifiers: type_specifier  */
+#line 330 "mini_c.y"
+        { (yyval.node) = new_spec_list((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 2382 "mini_c.tab.cpp"
+    break;
+
+  case 83: /* declaration_specifiers: type_specifier declaration_specifiers  */
+#line 332 "mini_c.y"
+        { (yyval.node) = append_spec_list((yyvsp[0].node), (yyvsp[-1].node), LOC((yylsp[-1]))); }
+#line 2388 "mini_c.tab.cpp"
+    break;
+
+  case 84: /* declaration_specifiers: type_qualifier  */
+#line 334 "mini_c.y"
+        { (yyval.node) = new_spec_list((yyvsp[0].ival), LOC((yylsp[0]))); }
+#line 2394 "mini_c.tab.cpp"
+    break;
+
+  case 85: /* declaration_specifiers: type_qualifier declaration_specifiers  */
+#line 336 "mini_c.y"
+        { (yyval.node) = append_spec_list((yyvsp[0].node), (yyvsp[-1].ival), LOC((yylsp[-1]))); }
+#line 2400 "mini_c.tab.cpp"
+    break;
+
+  case 86: /* declaration_specifiers: function_specifier  */
+#line 338 "mini_c.y"
+        { (yyval.node) = new_spec_list((yyvsp[0].ival), LOC((yylsp[0]))); }
+#line 2406 "mini_c.tab.cpp"
+    break;
+
+  case 87: /* declaration_specifiers: function_specifier declaration_specifiers  */
+#line 340 "mini_c.y"
+        { (yyval.node) = append_spec_list((yyvsp[0].node), (yyvsp[-1].ival), LOC((yylsp[-1]))); }
+#line 2412 "mini_c.tab.cpp"
+    break;
+
+  case 88: /* init_declarator_list: init_declarator  */
+#line 346 "mini_c.y"
+        { (yyval.node) = new_init_list((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 2418 "mini_c.tab.cpp"
+    break;
+
+  case 89: /* init_declarator_list: init_declarator_list ',' init_declarator  */
+#line 348 "mini_c.y"
+        { (yyval.node) = append_init_list((yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2424 "mini_c.tab.cpp"
+    break;
+
+  case 90: /* init_declarator: declarator  */
+#line 354 "mini_c.y"
+        { (yyval.node) = new_init_decl((yyvsp[0].node), NULL, LOC((yylsp[0]))); }
+#line 2430 "mini_c.tab.cpp"
+    break;
+
+  case 91: /* init_declarator: declarator '=' initializer  */
+#line 356 "mini_c.y"
+        { (yyval.node) = new_init_decl((yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2436 "mini_c.tab.cpp"
+    break;
+
+  case 92: /* storage_class_specifier: TYPEDEF  */
+#line 361 "mini_c.y"
+                { (yyval.ival) = SC_TYPEDEF; }
+#line 2442 "mini_c.tab.cpp"
+    break;
+
+  case 93: /* storage_class_specifier: EXTERN  */
+#line 362 "mini_c.y"
+                { (yyval.ival) = SC_EXTERN; }
+#line 2448 "mini_c.tab.cpp"
+    break;
+
+  case 94: /* storage_class_specifier: STATIC  */
+#line 363 "mini_c.y"
+                { (yyval.ival) = SC_STATIC; }
+#line 2454 "mini_c.tab.cpp"
+    break;
+
+  case 95: /* storage_class_specifier: AUTO  */
+#line 364 "mini_c.y"
+                { (yyval.ival) = SC_AUTO; }
+#line 2460 "mini_c.tab.cpp"
+    break;
+
+  case 96: /* storage_class_specifier: REGISTER  */
+#line 365 "mini_c.y"
+                { (yyval.ival) = SC_REGISTER; }
+#line 2466 "mini_c.tab.cpp"
+    break;
+
+  case 97: /* type_specifier: VOID  */
+#line 369 "mini_c.y"
+                 { (yyval.node) = make_type_spec_node(TS_VOID); }
+#line 2472 "mini_c.tab.cpp"
+    break;
+
+  case 98: /* type_specifier: CHAR  */
+#line 370 "mini_c.y"
+                 { (yyval.node) = make_type_spec_node(TS_CHAR); }
+#line 2478 "mini_c.tab.cpp"
+    break;
+
+  case 99: /* type_specifier: SHORT  */
+#line 371 "mini_c.y"
+                 { (yyval.node) = make_type_spec_node(TS_SHORT); }
+#line 2484 "mini_c.tab.cpp"
+    break;
+
+  case 100: /* type_specifier: INT  */
+#line 372 "mini_c.y"
+                 { (yyval.node) = make_type_spec_node(TS_INT); }
+#line 2490 "mini_c.tab.cpp"
+    break;
+
+  case 101: /* type_specifier: LONG  */
+#line 373 "mini_c.y"
+                 { (yyval.node) = make_type_spec_node(TS_LONG); }
+#line 2496 "mini_c.tab.cpp"
+    break;
+
+  case 102: /* type_specifier: FLOAT  */
+#line 374 "mini_c.y"
+                 { (yyval.node) = make_type_spec_node(TS_FLOAT); }
+#line 2502 "mini_c.tab.cpp"
+    break;
+
+  case 103: /* type_specifier: DOUBLE  */
+#line 375 "mini_c.y"
+                 { (yyval.node) = make_type_spec_node(TS_DOUBLE); }
+#line 2508 "mini_c.tab.cpp"
+    break;
+
+  case 104: /* type_specifier: SIGNED  */
+#line 376 "mini_c.y"
+                 { (yyval.node) = make_type_spec_node(TS_SIGNED); }
+#line 2514 "mini_c.tab.cpp"
+    break;
+
+  case 105: /* type_specifier: UNSIGNED  */
+#line 377 "mini_c.y"
+                 { (yyval.node) = make_type_spec_node(TS_UNSIGNED); }
+#line 2520 "mini_c.tab.cpp"
+    break;
+
+  case 106: /* type_specifier: BOOL  */
+#line 378 "mini_c.y"
+                 { (yyval.node) = make_type_spec_node(TS_BOOL); }
+#line 2526 "mini_c.tab.cpp"
+    break;
+
+  case 107: /* type_specifier: COMPLEX  */
+#line 379 "mini_c.y"
+                 { (yyval.node) = make_type_spec_node(TS_COMPLEX); }
+#line 2532 "mini_c.tab.cpp"
+    break;
+
+  case 108: /* type_specifier: IMAGINARY  */
+#line 380 "mini_c.y"
+                 { (yyval.node) = make_type_spec_node(TS_IMAGINARY); }
+#line 2538 "mini_c.tab.cpp"
+    break;
+
+  case 109: /* type_specifier: struct_or_union_specifier  */
+#line 382 "mini_c.y"
+        { (yyval.node) = (yyvsp[0].node); }
+#line 2544 "mini_c.tab.cpp"
+    break;
+
+  case 110: /* type_specifier: enum_specifier  */
+#line 384 "mini_c.y"
+        { (yyval.node) = (yyvsp[0].node); }
+#line 2550 "mini_c.tab.cpp"
+    break;
+
+  case 111: /* type_specifier: TYPE_NAME  */
+#line 386 "mini_c.y"
+        { (yyval.node) = make_type_spec_node(TS_TYPE_NAME); }
+#line 2556 "mini_c.tab.cpp"
+    break;
+
+  case 112: /* struct_or_union_specifier: struct_or_union IDENTIFIER '{' struct_declaration_list '}'  */
+#line 391 "mini_c.y"
+        { (yyval.node) = new_struct_su_node(static_cast<StructUnionKind>((yyvsp[-4].ival)), (yyvsp[-3].sval), (yyvsp[-1].node), LOC((yylsp[-3]))); }
+#line 2562 "mini_c.tab.cpp"
+    break;
+
+  case 113: /* struct_or_union_specifier: struct_or_union '{' struct_declaration_list '}'  */
+#line 393 "mini_c.y"
+        { (yyval.node) = new_struct_su_node(static_cast<StructUnionKind>((yyvsp[-3].ival)), nullptr, (yyvsp[-1].node), LOC((yylsp[-2]))); }
+#line 2568 "mini_c.tab.cpp"
+    break;
+
+  case 114: /* struct_or_union_specifier: struct_or_union IDENTIFIER  */
+#line 395 "mini_c.y"
+        { (yyval.node) = new_struct_su_node(static_cast<StructUnionKind>((yyvsp[-1].ival)), (yyvsp[0].sval), nullptr, LOC((yylsp[0]))); }
+#line 2574 "mini_c.tab.cpp"
+    break;
+
+  case 115: /* struct_or_union: STRUCT  */
+#line 401 "mini_c.y"
+              { (yyval.ival) = SU_STRUCT; }
+#line 2580 "mini_c.tab.cpp"
+    break;
+
+  case 116: /* struct_or_union: UNION  */
+#line 402 "mini_c.y"
+              { (yyval.ival) = SU_UNION; }
+#line 2586 "mini_c.tab.cpp"
+    break;
+
+  case 117: /* struct_declaration_list: struct_declaration  */
+#line 407 "mini_c.y"
+        { (yyval.node) = new_sdecl_list((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 2592 "mini_c.tab.cpp"
+    break;
+
+  case 118: /* struct_declaration_list: struct_declaration_list struct_declaration  */
+#line 409 "mini_c.y"
+        { (yyval.node) = append_sdecl_list((yyvsp[-1].node), (yyvsp[0].node), LOC((yylsp[0]))); }
+#line 2598 "mini_c.tab.cpp"
+    break;
+
+  case 119: /* struct_declaration: specifier_qualifier_list struct_declarator_list ';'  */
+#line 415 "mini_c.y"
+        { (yyval.node) = new_struct_decl((yyvsp[-2].node), (yyvsp[-1].node), LOC((yylsp[0]))); }
+#line 2604 "mini_c.tab.cpp"
+    break;
+
+  case 120: /* specifier_qualifier_list: type_specifier specifier_qualifier_list  */
+#line 420 "mini_c.y"
+        { (yyval.node) = append_specq_list((yyvsp[0].node), (yyvsp[-1].node), LOC((yylsp[-1]))); }
+#line 2610 "mini_c.tab.cpp"
+    break;
+
+  case 121: /* specifier_qualifier_list: type_specifier  */
+#line 422 "mini_c.y"
+        { (yyval.node) = new_specq_list((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 2616 "mini_c.tab.cpp"
+    break;
+
+  case 122: /* specifier_qualifier_list: type_qualifier specifier_qualifier_list  */
+#line 424 "mini_c.y"
+        { (yyval.node) = append_specq_list((yyvsp[0].node), (yyvsp[-1].ival), LOC((yylsp[-1]))); }
+#line 2622 "mini_c.tab.cpp"
+    break;
+
+  case 123: /* specifier_qualifier_list: type_qualifier  */
+#line 426 "mini_c.y"
+        { (yyval.node) = new_specq_list((yyvsp[0].ival), LOC((yylsp[0]))); }
+#line 2628 "mini_c.tab.cpp"
+    break;
+
+  case 124: /* struct_declarator_list: struct_declarator  */
+#line 432 "mini_c.y"
+        { (yyval.node) = new_sdeclarator_list((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 2634 "mini_c.tab.cpp"
+    break;
+
+  case 125: /* struct_declarator_list: struct_declarator_list ',' struct_declarator  */
+#line 434 "mini_c.y"
+        { (yyval.node) = append_sdeclarator_list((yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2640 "mini_c.tab.cpp"
+    break;
+
+  case 126: /* struct_declarator: declarator  */
+#line 440 "mini_c.y"
+        { (yyval.node) = (yyvsp[0].node); }
+#line 2646 "mini_c.tab.cpp"
+    break;
+
+  case 127: /* struct_declarator: ':' constant_expression  */
+#line 442 "mini_c.y"
+        { (yyval.node) = new_bitfield_node(NULL, (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2652 "mini_c.tab.cpp"
+    break;
+
+  case 128: /* struct_declarator: declarator ':' constant_expression  */
+#line 444 "mini_c.y"
+        { (yyval.node) = new_bitfield_node((yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2658 "mini_c.tab.cpp"
+    break;
+
+  case 129: /* enum_specifier: ENUM '{' enumerator_list '}'  */
+#line 450 "mini_c.y"
+        { (yyval.node) = new_enum_node(NULL, (yyvsp[-1].node), LOC((yylsp[-3]))); }
+#line 2664 "mini_c.tab.cpp"
+    break;
+
+  case 130: /* enum_specifier: ENUM IDENTIFIER '{' enumerator_list '}'  */
+#line 452 "mini_c.y"
+        { (yyval.node) = new_enum_node((yyvsp[-3].sval), (yyvsp[-1].node), LOC((yylsp[-4]))); }
+#line 2670 "mini_c.tab.cpp"
+    break;
+
+  case 131: /* enum_specifier: ENUM '{' enumerator_list ',' '}'  */
+#line 454 "mini_c.y"
+        { (yyval.node) = new_enum_node(NULL, (yyvsp[-2].node), LOC((yylsp[-4]))); }
+#line 2676 "mini_c.tab.cpp"
+    break;
+
+  case 132: /* enum_specifier: ENUM IDENTIFIER '{' enumerator_list ',' '}'  */
+#line 456 "mini_c.y"
+        { (yyval.node) = new_enum_node((yyvsp[-4].sval), (yyvsp[-2].node), LOC((yylsp[-5]))); }
+#line 2682 "mini_c.tab.cpp"
+    break;
+
+  case 133: /* enum_specifier: ENUM IDENTIFIER  */
+#line 458 "mini_c.y"
+        { (yyval.node) = new_enum_node((yyvsp[0].sval), NULL, LOC((yylsp[-1]))); }
+#line 2688 "mini_c.tab.cpp"
+    break;
+
+  case 134: /* enumerator_list: enumerator  */
+#line 464 "mini_c.y"
+        { (yyval.node) = new_enum_list((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 2694 "mini_c.tab.cpp"
+    break;
+
+  case 135: /* enumerator_list: enumerator_list ',' enumerator  */
+#line 466 "mini_c.y"
+        { (yyval.node) = append_enum_list((yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2700 "mini_c.tab.cpp"
+    break;
+
+  case 136: /* enumerator: IDENTIFIER  */
+#line 472 "mini_c.y"
+        { (yyval.node) = new_enum_const((yyvsp[0].sval), NULL, LOC((yylsp[0]))); }
+#line 2706 "mini_c.tab.cpp"
+    break;
+
+  case 137: /* enumerator: IDENTIFIER '=' constant_expression  */
+#line 474 "mini_c.y"
+        { (yyval.node) = new_enum_const((yyvsp[-2].sval), (yyvsp[0].node), LOC((yylsp[-2]))); }
+#line 2712 "mini_c.tab.cpp"
+    break;
+
+  case 138: /* type_qualifier: CONST  */
+#line 480 "mini_c.y"
+        { (yyval.ival) = TQ_CONST; }
+#line 2718 "mini_c.tab.cpp"
+    break;
+
+  case 139: /* type_qualifier: RESTRICT  */
+#line 482 "mini_c.y"
+        { (yyval.ival) = TQ_RESTRICT; }
+#line 2724 "mini_c.tab.cpp"
+    break;
+
+  case 140: /* type_qualifier: VOLATILE  */
+#line 484 "mini_c.y"
+        { (yyval.ival) = TQ_VOLATILE; }
+#line 2730 "mini_c.tab.cpp"
+    break;
+
+  case 141: /* function_specifier: INLINE  */
+#line 489 "mini_c.y"
+        { (yyval.ival) = FS_INLINE; }
+#line 2736 "mini_c.tab.cpp"
+    break;
+
+  case 142: /* declarator: pointer direct_declarator  */
+#line 494 "mini_c.y"
+        { (yyval.node) = new_declarator_node((yyvsp[-1].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2742 "mini_c.tab.cpp"
+    break;
+
+  case 143: /* declarator: direct_declarator  */
+#line 496 "mini_c.y"
+        { (yyval.node) = new_declarator_node(NULL, (yyvsp[0].node), LOC((yylsp[0]))); }
+#line 2748 "mini_c.tab.cpp"
+    break;
+
+  case 144: /* direct_declarator: IDENTIFIER  */
+#line 502 "mini_c.y"
+        { (yyval.node) = new_decl_ident((yyvsp[0].sval), LOC((yylsp[0]))); }
+#line 2754 "mini_c.tab.cpp"
+    break;
+
+  case 145: /* direct_declarator: '(' declarator ')'  */
+#line 504 "mini_c.y"
+        { (yyval.node) = (yyvsp[-1].node); (yyval.node)->loc = LOC((yylsp[0])); }
+#line 2760 "mini_c.tab.cpp"
+    break;
+
+  case 146: /* direct_declarator: direct_declarator '[' type_qualifier_list assignment_expression ']'  */
+#line 506 "mini_c.y"
+        { (yyval.node) = new_array_decl((yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[-1].node), NULL, NULL, LOC((yylsp[-3]))); }
+#line 2766 "mini_c.tab.cpp"
+    break;
+
+  case 147: /* direct_declarator: direct_declarator '[' type_qualifier_list ']'  */
+#line 508 "mini_c.y"
+        { (yyval.node) = new_array_decl((yyvsp[-3].node), (yyvsp[-1].node), NULL, NULL, NULL, LOC((yylsp[-2]))); }
+#line 2772 "mini_c.tab.cpp"
+    break;
+
+  case 148: /* direct_declarator: direct_declarator '[' assignment_expression ']'  */
+#line 510 "mini_c.y"
+        { (yyval.node) = new_array_decl((yyvsp[-3].node), NULL, (yyvsp[-1].node), NULL, NULL, LOC((yylsp[-2]))); }
+#line 2778 "mini_c.tab.cpp"
+    break;
+
+  case 149: /* direct_declarator: direct_declarator '[' STATIC type_qualifier_list assignment_expression ']'  */
+#line 512 "mini_c.y"
+        { (yyval.node) = new_array_decl((yyvsp[-5].node), (yyvsp[-2].node), (yyvsp[-1].node), true, NULL, LOC((yylsp[-4]))); }
+#line 2784 "mini_c.tab.cpp"
+    break;
+
+  case 150: /* direct_declarator: direct_declarator '[' type_qualifier_list STATIC assignment_expression ']'  */
+#line 514 "mini_c.y"
+        { (yyval.node) = new_array_decl((yyvsp[-5].node), (yyvsp[-3].node), (yyvsp[-1].node), true, NULL, LOC((yylsp[-4]))); }
+#line 2790 "mini_c.tab.cpp"
+    break;
+
+  case 151: /* direct_declarator: direct_declarator '[' type_qualifier_list '*' ']'  */
+#line 516 "mini_c.y"
+        { (yyval.node) = new_array_decl((yyvsp[-4].node), (yyvsp[-2].node), NULL, NULL, true, LOC((yylsp[-3]))); }
+#line 2796 "mini_c.tab.cpp"
+    break;
+
+  case 152: /* direct_declarator: direct_declarator '[' '*' ']'  */
+#line 518 "mini_c.y"
+        { (yyval.node) = new_array_decl((yyvsp[-3].node), NULL, NULL, NULL, true, LOC((yylsp[-2]))); }
+#line 2802 "mini_c.tab.cpp"
+    break;
+
+  case 153: /* direct_declarator: direct_declarator '[' ']'  */
+#line 520 "mini_c.y"
+        { (yyval.node) = new_array_decl((yyvsp[-2].node), NULL, NULL, NULL, false, LOC((yylsp[-1]))); }
+#line 2808 "mini_c.tab.cpp"
+    break;
+
+  case 154: /* direct_declarator: direct_declarator '(' parameter_type_list ')'  */
+#line 522 "mini_c.y"
+        { (yyval.node) = new_func_decl((yyvsp[-3].node), (yyvsp[-1].node), LOC((yylsp[-2]))); }
+#line 2814 "mini_c.tab.cpp"
+    break;
+
+  case 155: /* direct_declarator: direct_declarator '(' identifier_list ')'  */
+#line 524 "mini_c.y"
+        { (yyval.node) = new_oldstyle_func_decl((yyvsp[-3].node), (yyvsp[-1].node), LOC((yylsp[-2]))); }
+#line 2820 "mini_c.tab.cpp"
+    break;
+
+  case 156: /* direct_declarator: direct_declarator '(' ')'  */
+#line 526 "mini_c.y"
+        { (yyval.node) = new_func_decl((yyvsp[-2].node), NULL, LOC((yylsp[-1]))); }
+#line 2826 "mini_c.tab.cpp"
+    break;
+
+  case 157: /* pointer: '*'  */
+#line 532 "mini_c.y"
+        { (yyval.node) = new_pointer(NULL, LOC((yylsp[0]))); }
+#line 2832 "mini_c.tab.cpp"
+    break;
+
+  case 158: /* pointer: '*' type_qualifier_list  */
+#line 534 "mini_c.y"
+        { (yyval.node) = new_pointer((yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2838 "mini_c.tab.cpp"
+    break;
+
+  case 159: /* pointer: '*' pointer  */
+#line 536 "mini_c.y"
+        { (yyval.node) = prepend_pointer(NULL, (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2844 "mini_c.tab.cpp"
+    break;
+
+  case 160: /* pointer: '*' type_qualifier_list pointer  */
+#line 538 "mini_c.y"
+        { (yyval.node) = prepend_pointer((yyvsp[-1].node), (yyvsp[0].node), LOC((yylsp[-2]))); }
+#line 2850 "mini_c.tab.cpp"
+    break;
+
+  case 161: /* type_qualifier_list: type_qualifier  */
+#line 544 "mini_c.y"
+        { (yyval.node) = new_tq_list((yyvsp[0].ival), LOC((yylsp[0]))); }
+#line 2856 "mini_c.tab.cpp"
+    break;
+
+  case 162: /* type_qualifier_list: type_qualifier_list type_qualifier  */
+#line 546 "mini_c.y"
+        { (yyval.node) = append_tq_list((yyvsp[-1].node), (yyvsp[0].ival), LOC((yylsp[0]))); }
+#line 2862 "mini_c.tab.cpp"
+    break;
+
+  case 163: /* parameter_type_list: parameter_list  */
+#line 551 "mini_c.y"
+        { (yyval.node) = (yyvsp[0].node); }
+#line 2868 "mini_c.tab.cpp"
+    break;
+
+  case 164: /* parameter_type_list: parameter_list ',' ELLIPSIS  */
+#line 553 "mini_c.y"
+        { (yyval.node) = new_param_list_ellipsis((yyvsp[-2].node), LOC((yylsp[-1]))); }
+#line 2874 "mini_c.tab.cpp"
+    break;
+
+  case 165: /* parameter_list: parameter_declaration  */
+#line 559 "mini_c.y"
+        { (yyval.node) = new_param_list((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 2880 "mini_c.tab.cpp"
+    break;
+
+  case 166: /* parameter_list: parameter_list ',' parameter_declaration  */
+#line 561 "mini_c.y"
+        { (yyval.node) = append_param_list((yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2886 "mini_c.tab.cpp"
+    break;
+
+  case 167: /* parameter_declaration: declaration_specifiers declarator  */
+#line 567 "mini_c.y"
+        { (yyval.node) = new_param_decl((yyvsp[-1].node), (yyvsp[0].node), LOC((yylsp[0]))); }
+#line 2892 "mini_c.tab.cpp"
+    break;
+
+  case 168: /* parameter_declaration: declaration_specifiers abstract_declarator  */
+#line 569 "mini_c.y"
+        { (yyval.node) = new_param_decl((yyvsp[-1].node), (yyvsp[0].node), LOC((yylsp[0]))); }
+#line 2898 "mini_c.tab.cpp"
+    break;
+
+  case 169: /* parameter_declaration: declaration_specifiers  */
+#line 571 "mini_c.y"
+        { (yyval.node) = new_param_decl((yyvsp[0].node), NULL, LOC((yylsp[0]))); }
+#line 2904 "mini_c.tab.cpp"
+    break;
+
+  case 170: /* identifier_list: IDENTIFIER  */
+#line 577 "mini_c.y"
+        { (yyval.node) = new_id_list((yyvsp[0].sval), LOC((yylsp[0]))); }
+#line 2910 "mini_c.tab.cpp"
+    break;
+
+  case 171: /* identifier_list: identifier_list ',' IDENTIFIER  */
+#line 579 "mini_c.y"
+        { (yyval.node) = append_id_list((yyvsp[-2].node), (yyvsp[0].sval), LOC((yylsp[0]))); }
+#line 2916 "mini_c.tab.cpp"
+    break;
+
+  case 172: /* type_name: specifier_qualifier_list  */
+#line 584 "mini_c.y"
+        { (yyval.node) = new_type_name((yyvsp[0].node), NULL, LOC((yylsp[0]))); }
+#line 2922 "mini_c.tab.cpp"
+    break;
+
+  case 173: /* type_name: specifier_qualifier_list abstract_declarator  */
+#line 586 "mini_c.y"
+        { (yyval.node) = new_type_name((yyvsp[-1].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2928 "mini_c.tab.cpp"
+    break;
+
+  case 174: /* abstract_declarator: pointer  */
+#line 592 "mini_c.y"
+        { (yyval.node) = new_abs_decl((yyvsp[0].node), NULL, LOC((yylsp[0]))); }
+#line 2934 "mini_c.tab.cpp"
+    break;
+
+  case 175: /* abstract_declarator: direct_abstract_declarator  */
+#line 594 "mini_c.y"
+        { (yyval.node) = new_abs_decl(NULL, (yyvsp[0].node), LOC((yylsp[0]))); }
+#line 2940 "mini_c.tab.cpp"
+    break;
+
+  case 176: /* abstract_declarator: pointer direct_abstract_declarator  */
+#line 596 "mini_c.y"
+        { (yyval.node) = new_abs_decl((yyvsp[-1].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 2946 "mini_c.tab.cpp"
+    break;
+
+  case 177: /* direct_abstract_declarator: '(' abstract_declarator ')'  */
+#line 602 "mini_c.y"
+        { (yyval.node) = (yyvsp[-1].node); (yyval.node)->loc = LOC((yylsp[0])); }
+#line 2952 "mini_c.tab.cpp"
+    break;
+
+  case 178: /* direct_abstract_declarator: '[' ']'  */
+#line 604 "mini_c.y"
+        { (yyval.node) = new_abs_array(NULL, NULL, LOC((yylsp[-1]))); }
+#line 2958 "mini_c.tab.cpp"
+    break;
+
+  case 179: /* direct_abstract_declarator: '[' assignment_expression ']'  */
+#line 606 "mini_c.y"
+        { (yyval.node) = new_abs_array((yyvsp[-1].node), NULL, LOC((yylsp[-2]))); }
+#line 2964 "mini_c.tab.cpp"
+    break;
+
+  case 180: /* direct_abstract_declarator: direct_abstract_declarator '[' ']'  */
+#line 608 "mini_c.y"
+        { (yyval.node) = new_abs_array_child((yyvsp[-2].node), NULL, NULL, LOC((yylsp[-1]))); }
+#line 2970 "mini_c.tab.cpp"
+    break;
+
+  case 181: /* direct_abstract_declarator: direct_abstract_declarator '[' assignment_expression ']'  */
+#line 610 "mini_c.y"
+        { (yyval.node) = new_abs_array_child((yyvsp[-3].node), (yyvsp[-1].node), NULL, LOC((yylsp[-2]))); }
+#line 2976 "mini_c.tab.cpp"
+    break;
+
+  case 182: /* direct_abstract_declarator: '[' '*' ']'  */
+#line 612 "mini_c.y"
+        { (yyval.node) = new_abs_array(NULL, true, LOC((yylsp[-2]))); }
+#line 2982 "mini_c.tab.cpp"
+    break;
+
+  case 183: /* direct_abstract_declarator: direct_abstract_declarator '[' '*' ']'  */
+#line 614 "mini_c.y"
+        { (yyval.node) = new_abs_array_child((yyvsp[-3].node), NULL, true, LOC((yylsp[-2]))); }
+#line 2988 "mini_c.tab.cpp"
+    break;
+
+  case 184: /* direct_abstract_declarator: '(' ')'  */
+#line 616 "mini_c.y"
+        { (yyval.node) = new_abs_func(NULL, LOC((yylsp[-1]))); }
+#line 2994 "mini_c.tab.cpp"
+    break;
+
+  case 185: /* direct_abstract_declarator: '(' parameter_type_list ')'  */
+#line 618 "mini_c.y"
+        { (yyval.node) = new_abs_func((yyvsp[-1].node), LOC((yylsp[-2]))); }
+#line 3000 "mini_c.tab.cpp"
+    break;
+
+  case 186: /* direct_abstract_declarator: direct_abstract_declarator '(' ')'  */
+#line 620 "mini_c.y"
+        { (yyval.node) = new_abs_func_child((yyvsp[-2].node), NULL, LOC((yylsp[-1]))); }
+#line 3006 "mini_c.tab.cpp"
+    break;
+
+  case 187: /* direct_abstract_declarator: direct_abstract_declarator '(' parameter_type_list ')'  */
+#line 622 "mini_c.y"
+        { (yyval.node) = new_abs_func_child((yyvsp[-3].node), (yyvsp[-1].node), LOC((yylsp[-2]))); }
+#line 3012 "mini_c.tab.cpp"
+    break;
+
+  case 188: /* initializer: assignment_expression  */
+#line 628 "mini_c.y"
+        { (yyval.node) = new_init_expr((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 3018 "mini_c.tab.cpp"
+    break;
+
+  case 189: /* initializer: '{' initializer_list '}'  */
+#line 630 "mini_c.y"
+        { (yyval.node) = new_init_list_node((yyvsp[-1].node), LOC((yylsp[-2]))); }
+#line 3024 "mini_c.tab.cpp"
+    break;
+
+  case 190: /* initializer: '{' initializer_list ',' '}'  */
+#line 632 "mini_c.y"
+        { (yyval.node) = new_init_list_node((yyvsp[-2].node), LOC((yylsp[-3]))); }
+#line 3030 "mini_c.tab.cpp"
+    break;
+
+  case 191: /* initializer_list: initializer  */
+#line 638 "mini_c.y"
+        { (yyval.node) = new_init_item_list((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 3036 "mini_c.tab.cpp"
+    break;
+
+  case 192: /* initializer_list: designation initializer  */
+#line 640 "mini_c.y"
+        { (yyval.node) = new_designated_init((yyvsp[-1].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 3042 "mini_c.tab.cpp"
+    break;
+
+  case 193: /* initializer_list: initializer_list ',' initializer  */
+#line 642 "mini_c.y"
+        { (yyval.node) = append_init_item((yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 3048 "mini_c.tab.cpp"
+    break;
+
+  case 194: /* initializer_list: initializer_list ',' designation initializer  */
+#line 644 "mini_c.y"
+        { (yyval.node) = append_designated_init((yyvsp[-3].node), (yyvsp[-1].node), (yyvsp[0].node), LOC((yylsp[-2]))); }
+#line 3054 "mini_c.tab.cpp"
+    break;
+
+  case 195: /* designation: designator_list '='  */
+#line 650 "mini_c.y"
+        { (yyval.node) = (yyvsp[-1].node); }
+#line 3060 "mini_c.tab.cpp"
+    break;
+
+  case 196: /* designator_list: designator  */
+#line 656 "mini_c.y"
+        { (yyval.node) = new_designator_list((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 3066 "mini_c.tab.cpp"
+    break;
+
+  case 197: /* designator_list: designator_list designator  */
+#line 658 "mini_c.y"
+        { (yyval.node) = append_designator_list((yyvsp[-1].node), (yyvsp[0].node), LOC((yylsp[0]))); }
+#line 3072 "mini_c.tab.cpp"
+    break;
+
+  case 198: /* designator: '[' constant_expression ']'  */
+#line 663 "mini_c.y"
+        { (yyval.node) = new_array_designator((yyvsp[-1].node), LOC((yylsp[-2]))); }
+#line 3078 "mini_c.tab.cpp"
+    break;
+
+  case 199: /* designator: '.' IDENTIFIER  */
+#line 665 "mini_c.y"
+        { (yyval.node) = new_field_designator((yyvsp[0].sval), LOC((yylsp[-1]))); }
+#line 3084 "mini_c.tab.cpp"
+    break;
+
+  case 200: /* statement: labeled_statement  */
+#line 670 "mini_c.y"
+                              { (yyval.node) = (yyvsp[0].node); }
+#line 3090 "mini_c.tab.cpp"
+    break;
+
+  case 201: /* statement: compound_statement  */
+#line 671 "mini_c.y"
+                              { (yyval.node) = (yyvsp[0].node); }
+#line 3096 "mini_c.tab.cpp"
+    break;
+
+  case 202: /* statement: expression_statement  */
+#line 672 "mini_c.y"
+                              { (yyval.node) = (yyvsp[0].node); }
+#line 3102 "mini_c.tab.cpp"
+    break;
+
+  case 203: /* statement: selection_statement  */
+#line 673 "mini_c.y"
+                              { (yyval.node) = (yyvsp[0].node); }
+#line 3108 "mini_c.tab.cpp"
+    break;
+
+  case 204: /* statement: iteration_statement  */
+#line 674 "mini_c.y"
+                              { (yyval.node) = (yyvsp[0].node); }
+#line 3114 "mini_c.tab.cpp"
+    break;
+
+  case 205: /* statement: jump_statement  */
+#line 675 "mini_c.y"
+                              { (yyval.node) = (yyvsp[0].node); }
+#line 3120 "mini_c.tab.cpp"
+    break;
+
+  case 206: /* labeled_statement: IDENTIFIER ':' statement  */
+#line 681 "mini_c.y"
+        { (yyval.node) = new_labeled_stmt_id((yyvsp[-2].sval), (yyvsp[0].node), LOC((yylsp[-2]))); }
+#line 3126 "mini_c.tab.cpp"
+    break;
+
+  case 207: /* labeled_statement: CASE constant_expression ':' statement  */
+#line 683 "mini_c.y"
+        { (yyval.node) = new_case_stmt((yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-3]))); }
+#line 3132 "mini_c.tab.cpp"
+    break;
+
+  case 208: /* labeled_statement: DEFAULT ':' statement  */
+#line 685 "mini_c.y"
+        { (yyval.node) = new_default_stmt((yyvsp[0].node), LOC((yylsp[-2]))); }
+#line 3138 "mini_c.tab.cpp"
+    break;
+
+  case 209: /* compound_statement: '{' '}'  */
+#line 690 "mini_c.y"
+        { (yyval.node) = new_compound_stmt(NULL, LOC((yylsp[-1]))); }
+#line 3144 "mini_c.tab.cpp"
+    break;
+
+  case 210: /* compound_statement: '{' block_item_list '}'  */
+#line 692 "mini_c.y"
+        { (yyval.node) = new_compound_stmt((yyvsp[-1].node), LOC((yylsp[-2]))); }
+#line 3150 "mini_c.tab.cpp"
+    break;
+
+  case 211: /* block_item_list: block_item  */
+#line 698 "mini_c.y"
+        { (yyval.node) = new_block_item_list((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 3156 "mini_c.tab.cpp"
+    break;
+
+  case 212: /* block_item_list: block_item_list block_item  */
+#line 700 "mini_c.y"
+        { (yyval.node) = append_block_item_list((yyvsp[-1].node), (yyvsp[0].node), LOC((yylsp[0]))); }
+#line 3162 "mini_c.tab.cpp"
+    break;
+
+  case 213: /* block_item: declaration  */
+#line 706 "mini_c.y"
+        { (yyval.node) = new_block_decl((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 3168 "mini_c.tab.cpp"
+    break;
+
+  case 214: /* block_item: statement  */
+#line 708 "mini_c.y"
+        { (yyval.node) = new_block_stmt((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 3174 "mini_c.tab.cpp"
+    break;
+
+  case 215: /* expression_statement: ';'  */
+#line 714 "mini_c.y"
+        { (yyval.node) = NULL; }
+#line 3180 "mini_c.tab.cpp"
+    break;
+
+  case 216: /* expression_statement: expression ';'  */
+#line 716 "mini_c.y"
+        { (yyval.node) = new_expr_stmt((yyvsp[-1].node), LOC((yylsp[0]))); }
+#line 3186 "mini_c.tab.cpp"
+    break;
+
+  case 217: /* selection_statement: IF '(' expression ')' statement  */
+#line 721 "mini_c.y"
+        { (yyval.node) = new_if_stmt((yyvsp[-2].node), (yyvsp[0].node), NULL, LOC((yylsp[-4]))); }
+#line 3192 "mini_c.tab.cpp"
+    break;
+
+  case 218: /* selection_statement: IF '(' expression ')' statement ELSE statement  */
+#line 723 "mini_c.y"
+        { (yyval.node) = new_if_stmt((yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-6]))); }
+#line 3198 "mini_c.tab.cpp"
+    break;
+
+  case 219: /* selection_statement: SWITCH '(' expression ')' statement  */
+#line 725 "mini_c.y"
+        { (yyval.node) = new_switch_stmt((yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-4]))); }
+#line 3204 "mini_c.tab.cpp"
+    break;
+
+  case 220: /* iteration_statement: WHILE '(' expression ')' statement  */
+#line 730 "mini_c.y"
+        { (yyval.node) = new_while_stmt((yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-4]))); }
+#line 3210 "mini_c.tab.cpp"
+    break;
+
+  case 221: /* iteration_statement: DO statement WHILE '(' expression ')' ';'  */
+#line 732 "mini_c.y"
+        { (yyval.node) = new_do_while_stmt((yyvsp[-5].node), (yyvsp[-2].node), LOC((yylsp[-6]))); }
+#line 3216 "mini_c.tab.cpp"
+    break;
+
+  case 222: /* iteration_statement: FOR '(' expression_statement expression_statement ')' statement  */
+#line 734 "mini_c.y"
+        { (yyval.node) = new_for_stmt((yyvsp[-3].node), (yyvsp[-2].node), NULL, (yyvsp[0].node), LOC((yylsp[-5]))); }
+#line 3222 "mini_c.tab.cpp"
+    break;
+
+  case 223: /* iteration_statement: FOR '(' expression_statement expression_statement expression ')' statement  */
+#line 736 "mini_c.y"
+        { (yyval.node) = new_for_stmt((yyvsp[-4].node), (yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-6]))); }
+#line 3228 "mini_c.tab.cpp"
+    break;
+
+  case 224: /* iteration_statement: FOR '(' declaration expression_statement ')' statement  */
+#line 738 "mini_c.y"
+        { (yyval.node) = new_for_decl_stmt((yyvsp[-3].node), (yyvsp[-2].node), NULL, (yyvsp[0].node), LOC((yylsp[-5]))); }
+#line 3234 "mini_c.tab.cpp"
+    break;
+
+  case 225: /* iteration_statement: FOR '(' declaration expression_statement expression ')' statement  */
+#line 740 "mini_c.y"
+        { (yyval.node) = new_for_decl_stmt((yyvsp[-4].node), (yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[0].node), LOC((yylsp[-6]))); }
+#line 3240 "mini_c.tab.cpp"
+    break;
+
+  case 226: /* jump_statement: GOTO IDENTIFIER ';'  */
+#line 746 "mini_c.y"
+        { (yyval.node) = new_goto_stmt((yyvsp[-1].sval), LOC((yylsp[-2]))); }
+#line 3246 "mini_c.tab.cpp"
+    break;
+
+  case 227: /* jump_statement: CONTINUE ';'  */
+#line 748 "mini_c.y"
+        { (yyval.node) = new_continue_stmt(LOC((yylsp[-1]))); }
+#line 3252 "mini_c.tab.cpp"
+    break;
+
+  case 228: /* jump_statement: BREAK ';'  */
+#line 750 "mini_c.y"
+        { (yyval.node) = new_break_stmt(LOC((yylsp[-1]))); }
+#line 3258 "mini_c.tab.cpp"
+    break;
+
+  case 229: /* jump_statement: RETURN ';'  */
+#line 752 "mini_c.y"
+        { (yyval.node) = new_return_stmt(NULL, LOC((yylsp[-1]))); }
+#line 3264 "mini_c.tab.cpp"
+    break;
+
+  case 230: /* jump_statement: RETURN expression ';'  */
+#line 754 "mini_c.y"
+        { (yyval.node) = new_return_stmt((yyvsp[-1].node), LOC((yylsp[-2]))); }
+#line 3270 "mini_c.tab.cpp"
+    break;
+
+  case 231: /* translation_unit: external_declaration  */
+#line 760 "mini_c.y"
+        { ast_root = (yyval.node) = (yyvsp[0].node); }
+#line 3276 "mini_c.tab.cpp"
+    break;
+
+  case 232: /* translation_unit: translation_unit external_declaration  */
+#line 762 "mini_c.y"
+        { ast_root = (yyval.node) = new_translation_unit((yyvsp[-1].node), (yyvsp[0].node), LOC((yylsp[0]))); }
+#line 3282 "mini_c.tab.cpp"
+    break;
+
+  case 233: /* external_declaration: function_definition  */
+#line 767 "mini_c.y"
+        { (yyval.node) = (yyvsp[0].node); }
+#line 3288 "mini_c.tab.cpp"
+    break;
+
+  case 234: /* external_declaration: declaration  */
+#line 769 "mini_c.y"
+        { (yyval.node) = new_decl_stmt((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 3294 "mini_c.tab.cpp"
+    break;
+
+  case 235: /* function_definition: declaration_specifiers declarator declaration_list compound_statement  */
+#line 775 "mini_c.y"
+        { (yyval.node) = new_function_def((yyvsp[-3].node), (yyvsp[-2].node), (yyvsp[-1].node), (yyvsp[0].node), LOC((yylsp[-2]))); }
+#line 3300 "mini_c.tab.cpp"
+    break;
+
+  case 236: /* function_definition: declaration_specifiers declarator compound_statement  */
+#line 777 "mini_c.y"
+        { (yyval.node) = new_function_def((yyvsp[-2].node), (yyvsp[-1].node), NULL, (yyvsp[0].node), LOC((yylsp[-1]))); }
+#line 3306 "mini_c.tab.cpp"
+    break;
+
+  case 237: /* declaration_list: declaration  */
+#line 783 "mini_c.y"
+        { (yyval.node) = new_declaration_list((yyvsp[0].node), LOC((yylsp[0]))); }
+#line 3312 "mini_c.tab.cpp"
+    break;
+
+  case 238: /* declaration_list: declaration_list declaration  */
+#line 785 "mini_c.y"
+        { (yyval.node) = append_declaration_list((yyvsp[-1].node), (yyvsp[0].node), LOC((yylsp[0]))); }
+#line 3318 "mini_c.tab.cpp"
+    break;
+
+
+#line 3322 "mini_c.tab.cpp"
+
+      default: break;
+    }
+  /* User semantic actions sometimes alter yychar, and that requires
+     that yytoken be updated with the new translation.  We take the
+     approach of translating immediately before every use of yytoken.
+     One alternative is translating here after every semantic action,
+     but that translation would be missed if the semantic action invokes
+     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
+     incorrect destructor might then be invoked immediately.  In the
+     case of YYERROR or YYBACKUP, subsequent parser actions might lead
+     to an incorrect destructor call or verbose syntax error message
+     before the lookahead is translated.  */
+  YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
+
+  YYPOPSTACK (yylen);
+  yylen = 0;
+
+  *++yyvsp = yyval;
+  *++yylsp = yyloc;
+
+  /* Now 'shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
+  {
+    const int yylhs = yyr1[yyn] - YYNTOKENS;
+    const int yyi = yypgoto[yylhs] + *yyssp;
+    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
+               ? yytable[yyi]
+               : yydefgoto[yylhs]);
+  }
+
+  goto yynewstate;
+
+
+/*--------------------------------------.
+| yyerrlab -- here on detecting error.  |
+`--------------------------------------*/
+yyerrlab:
+  /* Make sure we have latest lookahead translation.  See comments at
+     user semantic actions for why this is necessary.  */
+  yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
+    {
+      ++yynerrs;
+      yyerror (YY_("syntax error"));
+    }
+
+  yyerror_range[1] = yylloc;
+  if (yyerrstatus == 3)
+    {
+      /* If just tried and failed to reuse lookahead token after an
+         error, discard it.  */
+
+      if (yychar <= YYEOF)
+        {
+          /* Return failure if at end of input.  */
+          if (yychar == YYEOF)
+            YYABORT;
+        }
+      else
+        {
+          yydestruct ("Error: discarding",
+                      yytoken, &yylval, &yylloc);
+          yychar = YYEMPTY;
+        }
+    }
+
+  /* Else will try to reuse lookahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+  /* Pacify compilers when the user code never invokes YYERROR and the
+     label yyerrorlab therefore never appears in user code.  */
+  if (0)
+    YYERROR;
+  ++yynerrs;
+
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
+
+  /* Pop stack until we find a state that shifts the error token.  */
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (!yypact_value_is_default (yyn))
+        {
+          yyn += YYSYMBOL_YYerror;
+          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
+            {
+              yyn = yytable[yyn];
+              if (0 < yyn)
+                break;
+            }
+        }
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
+        YYABORT;
+
+      yyerror_range[1] = *yylsp;
+      yydestruct ("Error: popping",
+                  YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
+    }
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+  yyerror_range[2] = yylloc;
+  ++yylsp;
+  YYLLOC_DEFAULT (*yylsp, yyerror_range, 2);
+
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturnlab;
+
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturnlab;
+
+
+/*-----------------------------------------------------------.
+| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here.  |
+`-----------------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (YY_("memory exhausted"));
+  yyresult = 2;
+  goto yyreturnlab;
+
+
+/*----------------------------------------------------------.
+| yyreturnlab -- parsing is finished, clean up and return.  |
+`----------------------------------------------------------*/
+yyreturnlab:
+  if (yychar != YYEMPTY)
+    {
+      /* Make sure we have latest lookahead translation.  See comments at
+         user semantic actions for why this is necessary.  */
+      yytoken = YYTRANSLATE (yychar);
+      yydestruct ("Cleanup: discarding lookahead",
+                  yytoken, &yylval, &yylloc);
+    }
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+                  YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp);
+      YYPOPSTACK (1);
+    }
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+
+  return yyresult;
+}
+
+#line 789 "mini_c.y"
+
+#include <stdio.h>
+
+extern char yytext[];
+extern int column;
+
+void yyerror(char const *s)
+{
+    fflush(stdout);
+    printf("\n%*s\n%*s\n", column, "^", column, s);
+}
diff --git a/mini_c.tab.hpp b/mini_c.tab.hpp
new file mode 100644
index 0000000..a4cf65c
--- /dev/null
+++ b/mini_c.tab.hpp
@@ -0,0 +1,164 @@
+/* A Bison parser, made by GNU Bison 3.8.2.  */
+
+/* Bison interface for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
+   Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
+   especially those whose name start with YY_ or yy_.  They are
+   private implementation details that can be changed or removed.  */
+
+#ifndef YY_YY_MINI_C_TAB_HPP_INCLUDED
+# define YY_YY_MINI_C_TAB_HPP_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int yydebug;
+#endif
+
+/* Token kinds.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    YYEMPTY = -2,
+    YYEOF = 0,                     /* "end of file"  */
+    YYerror = 256,                 /* error  */
+    YYUNDEF = 257,                 /* "invalid token"  */
+    LOWER_THAN_ELSE = 258,         /* LOWER_THAN_ELSE  */
+    IDENTIFIER = 259,              /* IDENTIFIER  */
+    CONSTANT = 260,                /* CONSTANT  */
+    STRING_LITERAL = 261,          /* STRING_LITERAL  */
+    TYPE_NAME = 262,               /* TYPE_NAME  */
+    SIZEOF = 263,                  /* SIZEOF  */
+    PTR_OP = 264,                  /* PTR_OP  */
+    INC_OP = 265,                  /* INC_OP  */
+    DEC_OP = 266,                  /* DEC_OP  */
+    LEFT_OP = 267,                 /* LEFT_OP  */
+    RIGHT_OP = 268,                /* RIGHT_OP  */
+    LE_OP = 269,                   /* LE_OP  */
+    GE_OP = 270,                   /* GE_OP  */
+    EQ_OP = 271,                   /* EQ_OP  */
+    NE_OP = 272,                   /* NE_OP  */
+    AND_OP = 273,                  /* AND_OP  */
+    OR_OP = 274,                   /* OR_OP  */
+    MUL_ASSIGN = 275,              /* MUL_ASSIGN  */
+    DIV_ASSIGN = 276,              /* DIV_ASSIGN  */
+    MOD_ASSIGN = 277,              /* MOD_ASSIGN  */
+    ADD_ASSIGN = 278,              /* ADD_ASSIGN  */
+    SUB_ASSIGN = 279,              /* SUB_ASSIGN  */
+    LEFT_ASSIGN = 280,             /* LEFT_ASSIGN  */
+    RIGHT_ASSIGN = 281,            /* RIGHT_ASSIGN  */
+    AND_ASSIGN = 282,              /* AND_ASSIGN  */
+    XOR_ASSIGN = 283,              /* XOR_ASSIGN  */
+    OR_ASSIGN = 284,               /* OR_ASSIGN  */
+    TYPEDEF = 285,                 /* TYPEDEF  */
+    EXTERN = 286,                  /* EXTERN  */
+    STATIC = 287,                  /* STATIC  */
+    AUTO = 288,                    /* AUTO  */
+    REGISTER = 289,                /* REGISTER  */
+    INLINE = 290,                  /* INLINE  */
+    RESTRICT = 291,                /* RESTRICT  */
+    CHAR = 292,                    /* CHAR  */
+    SHORT = 293,                   /* SHORT  */
+    INT = 294,                     /* INT  */
+    LONG = 295,                    /* LONG  */
+    SIGNED = 296,                  /* SIGNED  */
+    UNSIGNED = 297,                /* UNSIGNED  */
+    FLOAT = 298,                   /* FLOAT  */
+    DOUBLE = 299,                  /* DOUBLE  */
+    CONST = 300,                   /* CONST  */
+    VOLATILE = 301,                /* VOLATILE  */
+    VOID = 302,                    /* VOID  */
+    BOOL = 303,                    /* BOOL  */
+    COMPLEX = 304,                 /* COMPLEX  */
+    IMAGINARY = 305,               /* IMAGINARY  */
+    STRUCT = 306,                  /* STRUCT  */
+    UNION = 307,                   /* UNION  */
+    ENUM = 308,                    /* ENUM  */
+    ELLIPSIS = 309,                /* ELLIPSIS  */
+    CASE = 310,                    /* CASE  */
+    DEFAULT = 311,                 /* DEFAULT  */
+    IF = 312,                      /* IF  */
+    ELSE = 313,                    /* ELSE  */
+    SWITCH = 314,                  /* SWITCH  */
+    WHILE = 315,                   /* WHILE  */
+    DO = 316,                      /* DO  */
+    FOR = 317,                     /* FOR  */
+    GOTO = 318,                    /* GOTO  */
+    CONTINUE = 319,                /* CONTINUE  */
+    BREAK = 320,                   /* BREAK  */
+    RETURN = 321                   /* RETURN  */
+  };
+  typedef enum yytokentype yytoken_kind_t;
+#endif
+
+/* Value type.  */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+union YYSTYPE
+{
+#line 26 "mini_c.y"
+
+    int       ival;   /* 运算符枚举、数值常量等整数值 */
+    char     *sval;   /* 标识符、字符串、常量的原始文本 */
+    ASTNode  *node;   /* AST 子树 */
+
+#line 136 "mini_c.tab.hpp"
+
+};
+typedef union YYSTYPE YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+/* Location type.  */
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE YYLTYPE;
+struct YYLTYPE
+{
+  int first_line;
+  int first_column;
+  int last_line;
+  int last_column;
+};
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+#endif
+
+
+extern YYSTYPE yylval;
+extern YYLTYPE yylloc;
+
+int yyparse (void);
+
+
+#endif /* !YY_YY_MINI_C_TAB_HPP_INCLUDED  */
diff --git a/mini_c.y b/mini_c.y
new file mode 100644
index 0000000..82c8878
--- /dev/null
+++ b/mini_c.y
@@ -0,0 +1,799 @@
+%defines
+%output "mini_c.tab.cpp"
+%{
+#include <stdio.h>
+#include "ast.h"            /* 定义了 ASTNode 结构和 new_* 系列函数 */
+ASTNode *ast_root = NULL;  /* 最终的 AST 根 */
+int yylex(void);
+void yyerror(const char *s);
+
+#define LOC(YYL) SourceLoc{ (YYL).first_line, (YYL).first_column }
+
+static ASTNode* make_type_spec_node(int ts)
+{
+    ASTNode* n = new ASTNode(ASTTag::SPECIFIER);
+    n->ival = ts;
+    return n;
+}
+
+%}
+
+%nonassoc LOWER_THAN_ELSE
+%nonassoc ELSE
+
+%locations
+
+%union {
+    int       ival;   /* 运算符枚举、数值常量等整数值 */
+    char     *sval;   /* 标识符、字符串、常量的原始文本 */
+    ASTNode  *node;   /* AST 子树 */
+}
+
+/*—— 所有会产生 ASTNode* 的 nonterminal ——*/
+%type <node>
+    primary_expression
+    postfix_expression
+    argument_expression_list
+    unary_expression
+    cast_expression
+    multiplicative_expression
+    additive_expression
+    shift_expression
+    relational_expression
+    equality_expression
+    and_expression
+    exclusive_or_expression
+    inclusive_or_expression
+    logical_and_expression
+    logical_or_expression
+    conditional_expression
+    assignment_expression
+    expression
+    constant_expression
+
+    declaration
+    declaration_specifiers
+    init_declarator_list
+    init_declarator
+
+
+    struct_or_union_specifier
+
+    struct_declaration_list
+    struct_declaration
+    specifier_qualifier_list
+    struct_declarator_list
+    struct_declarator
+
+    enum_specifier
+    enumerator_list
+    enumerator
+
+
+
+    declarator
+    direct_declarator
+    pointer
+
+    type_qualifier_list
+    parameter_type_list
+    parameter_list
+    parameter_declaration
+    identifier_list
+
+    type_name
+    abstract_declarator
+    direct_abstract_declarator
+
+    initializer
+    initializer_list
+    designation
+    designator_list
+    designator
+
+    statement
+    labeled_statement
+    compound_statement
+    block_item_list
+    block_item
+
+    expression_statement
+    selection_statement
+    iteration_statement
+    jump_statement
+
+    translation_unit
+    external_declaration
+    function_definition
+    declaration_list
+;
+
+/*—— 运算符枚举，用 ival 存 ——*/
+%type <ival> assignment_operator unary_operator
+
+%type <ival> storage_class_specifier type_qualifier function_specifier
+%type <node> type_specifier
+
+%type <ival> struct_or_union
+
+
+
+/*—— token 的语义值类型 ——*/
+%token  <sval> IDENTIFIER
+%token  <sval> CONSTANT
+%token  <sval> STRING_LITERAL
+%token  <sval> TYPE_NAME
+%token         SIZEOF
+
+%token         PTR_OP INC_OP DEC_OP LEFT_OP RIGHT_OP
+%token         LE_OP GE_OP EQ_OP NE_OP AND_OP OR_OP
+%token         MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN SUB_ASSIGN
+%token         LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN XOR_ASSIGN OR_ASSIGN
+
+%token         TYPEDEF EXTERN STATIC AUTO REGISTER INLINE RESTRICT
+%token         CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST VOLATILE VOID
+%token         BOOL COMPLEX IMAGINARY
+%token         STRUCT UNION ENUM ELLIPSIS
+%token         CASE DEFAULT IF ELSE SWITCH WHILE DO FOR GOTO CONTINUE BREAK RETURN
+
+%start translation_unit
+%%
+
+
+primary_expression
+    : IDENTIFIER              { $$ = new_id_node($1, LOC(@1)); }
+    | CONSTANT                { $$ = new_const_node($1, LOC(@1)); }
+    | STRING_LITERAL          { $$ = new_string_node($1, LOC(@1)); }
+    | '(' expression ')'      { $$ = $2; $$->loc = LOC(@3); }
+    ;
+
+postfix_expression
+    : primary_expression                                           { $$ = $1; }
+    | postfix_expression '[' expression ']'                        { $$ = new_array_ref_node($1, $3, LOC(@2)); }
+    | postfix_expression '(' ')'                                   { $$ = new_func_call_node($1, NULL, LOC(@2)); }
+    | postfix_expression '(' argument_expression_list ')'          { $$ = new_func_call_node($1, $3, LOC(@2)); }
+    | postfix_expression '.' IDENTIFIER                            { $$ = new_struct_ref_node($1, $3, false, LOC(@2)); }
+    | postfix_expression PTR_OP IDENTIFIER                         { $$ = new_struct_ref_node($1, $3, true, LOC(@2)); }
+    | postfix_expression INC_OP                                    { $$ = new_post_inc_node($1, LOC(@2)); }
+    | postfix_expression DEC_OP                                    { $$ = new_post_dec_node($1, LOC(@2)); }
+    | '(' type_name ')' '{' initializer_list '}'                   { $$ = new_compound_literal_node($2, $5, LOC(@1)); }
+    | '(' type_name ')' '{' initializer_list ',' '}'               { $$ = new_compound_literal_node($2, $5, LOC(@1)); }
+    ;
+
+
+argument_expression_list
+    : assignment_expression                                        { $$ = new_arg_list($1, LOC(@1)); }
+    | argument_expression_list ',' assignment_expression           { $$ = append_arg_list($1, $3, LOC(@2)); }
+    ;
+
+unary_expression
+    : postfix_expression                                           { $$ = $1; }
+    | INC_OP unary_expression                                      { $$ = new_pre_inc_node($2, LOC(@1)); }
+    | DEC_OP unary_expression                                      { $$ = new_pre_dec_node($2, LOC(@1)); }
+    | unary_operator cast_expression                               { $$ = new_unary_op_node($1, $2, LOC(@1)); }
+    | SIZEOF unary_expression                                      { $$ = new_sizeof_node($2, false, LOC(@1)); }
+    | SIZEOF '(' type_name ')'                                     { $$ = new_sizeof_node($3, true, LOC(@1)); }
+    ;
+
+unary_operator
+    : '&'   { $$ = op_address; }
+    | '*'   { $$ = op_deref; }
+    | '+'   { $$ = op_unary_plus; }
+    | '-'   { $$ = op_neg; }
+    | '~'   { $$ = op_bitnot; }
+    | '!'   { $$ = op_not; }
+    ;
+
+
+cast_expression
+    : unary_expression                                             { $$ = $1; }
+    | '(' type_name ')' cast_expression                            { $$ = new_cast_node($2, $4, LOC(@1)); }
+    ;
+
+multiplicative_expression
+    : cast_expression                                              { $$ = $1; }
+    | multiplicative_expression '*' cast_expression                { $$ = new_binop_node('*', $1, $3, LOC(@2)); }
+    | multiplicative_expression '/' cast_expression                { $$ = new_binop_node('/', $1, $3, LOC(@2)); }
+    | multiplicative_expression '%' cast_expression                { $$ = new_binop_node('%', $1, $3, LOC(@2)); }
+    ;
+
+
+additive_expression
+    : multiplicative_expression                                    { $$ = $1; }
+    | additive_expression '+' multiplicative_expression            { $$ = new_binop_node('+', $1, $3, LOC(@2)); }
+    | additive_expression '-' multiplicative_expression            { $$ = new_binop_node('-', $1, $3, LOC(@2)); }
+    ;
+
+
+shift_expression
+    : additive_expression                                          { $$ = $1; }
+    | shift_expression LEFT_OP additive_expression                 { $$ = new_binop_node(SHL, $1, $3, LOC(@2)); }
+    | shift_expression RIGHT_OP additive_expression                { $$ = new_binop_node(SHR, $1, $3, LOC(@2)); }
+    ;
+
+
+relational_expression
+    : shift_expression                                             { $$ = $1; }
+    | relational_expression '<' shift_expression                   { $$ = new_binop_node('<', $1, $3, LOC(@2)); }
+    | relational_expression '>' shift_expression                   { $$ = new_binop_node('>', $1, $3, LOC(@2)); }
+    | relational_expression LE_OP shift_expression                 { $$ = new_binop_node(LE, $1, $3, LOC(@2)); }
+    | relational_expression GE_OP shift_expression                 { $$ = new_binop_node(GE, $1, $3, LOC(@2)); }
+    ;
+
+
+equality_expression
+    : relational_expression                                        { $$ = $1; }
+    | equality_expression EQ_OP relational_expression              { $$ = new_binop_node(EQ, $1, $3, LOC(@2)); }
+    | equality_expression NE_OP relational_expression              { $$ = new_binop_node(NE, $1, $3, LOC(@2)); }
+    ;
+
+
+
+and_expression
+    : equality_expression
+        { $$ = $1; }
+    | and_expression '&' equality_expression
+        { $$ = new_binop_node('&', $1, $3, LOC(@2)); }
+    ;
+
+
+exclusive_or_expression
+    : and_expression
+        { $$ = $1; }
+    | exclusive_or_expression '^' and_expression
+        { $$ = new_binop_node('^', $1, $3, LOC(@2)); }
+    ;
+
+
+inclusive_or_expression
+    : exclusive_or_expression
+        { $$ = $1; }
+    | inclusive_or_expression '|' exclusive_or_expression
+        { $$ = new_binop_node('|', $1, $3, LOC(@2)); }
+    ;
+
+
+logical_and_expression
+    : inclusive_or_expression
+        { $$ = $1; }
+    | logical_and_expression AND_OP inclusive_or_expression
+        { $$ = new_logical_and_node($1, $3, LOC(@2)); }
+    ;
+
+
+logical_or_expression
+    : logical_and_expression
+        { $$ = $1; }
+    | logical_or_expression OR_OP logical_and_expression
+        { $$ = new_logical_or_node($1, $3, LOC(@2)); }
+    ;
+
+
+conditional_expression
+    : logical_or_expression
+        { $$ = $1; }
+    | logical_or_expression '?' expression ':' conditional_expression
+        { $$ = new_conditional_node($1, $3, $5, LOC(@2)); }
+    ;
+
+
+assignment_expression
+    : conditional_expression
+        { $$ = $1; }
+    | unary_expression assignment_operator assignment_expression
+        { $$ = new_assign_node($1, $2, $3, LOC(@2)); }
+    ;
+
+
+assignment_operator
+    : '='           { $$ = op_assign; }
+    | MUL_ASSIGN    { $$ = op_mul_assign; }
+    | DIV_ASSIGN    { $$ = op_div_assign; }
+    | MOD_ASSIGN    { $$ = op_mod_assign; }
+    | ADD_ASSIGN    { $$ = op_add_assign; }
+    | SUB_ASSIGN    { $$ = op_sub_assign; }
+    | LEFT_ASSIGN   { $$ = op_shl_assign; }
+    | RIGHT_ASSIGN  { $$ = op_shr_assign; }
+    | AND_ASSIGN    { $$ = op_and_assign; }
+    | XOR_ASSIGN    { $$ = op_xor_assign; }
+    | OR_ASSIGN     { $$ = op_or_assign; }
+    ;
+
+expression
+    : assignment_expression
+        { $$ = $1; }
+    | expression ',' assignment_expression
+        { $$ = new_expr_list($1, $3, LOC(@2)); }
+    ;
+
+
+constant_expression
+    : conditional_expression
+        { $$ = $1; }
+    ;
+
+/* 声明相关 */
+declaration
+    : declaration_specifiers ';'
+        { $$ = new_decl_stmt($1, LOC(@2)); }
+    | declaration_specifiers init_declarator_list ';'
+        { $$ = new_declaration($1, $2, LOC(@3)); }
+    ;
+
+
+declaration_specifiers
+    : storage_class_specifier
+        { $$ = new_spec_list($1, LOC(@1)); }
+    | storage_class_specifier declaration_specifiers
+        { $$ = append_spec_list($2, $1, LOC(@1)); }
+    | type_specifier
+        { $$ = new_spec_list($1, LOC(@1)); }
+    | type_specifier declaration_specifiers
+        { $$ = append_spec_list($2, $1, LOC(@1)); }
+    | type_qualifier
+        { $$ = new_spec_list($1, LOC(@1)); }
+    | type_qualifier declaration_specifiers
+        { $$ = append_spec_list($2, $1, LOC(@1)); }
+    | function_specifier
+        { $$ = new_spec_list($1, LOC(@1)); }
+    | function_specifier declaration_specifiers
+        { $$ = append_spec_list($2, $1, LOC(@1)); }
+    ;
+
+
+init_declarator_list
+    : init_declarator
+        { $$ = new_init_list($1, LOC(@1)); }
+    | init_declarator_list ',' init_declarator
+        { $$ = append_init_list($1, $3, LOC(@2)); }
+    ;
+
+
+init_declarator
+    : declarator
+        { $$ = new_init_decl($1, NULL, LOC(@1)); }
+    | declarator '=' initializer
+        { $$ = new_init_decl($1, $3, LOC(@2)); }
+    ;
+
+
+storage_class_specifier
+    : TYPEDEF   { $$ = SC_TYPEDEF; }
+    | EXTERN    { $$ = SC_EXTERN; }
+    | STATIC    { $$ = SC_STATIC; }
+    | AUTO      { $$ = SC_AUTO; }
+    | REGISTER  { $$ = SC_REGISTER; }
+    ;
+
+type_specifier
+    : VOID       { $$ = make_type_spec_node(TS_VOID); }
+    | CHAR       { $$ = make_type_spec_node(TS_CHAR); }
+    | SHORT      { $$ = make_type_spec_node(TS_SHORT); }
+    | INT        { $$ = make_type_spec_node(TS_INT); }
+    | LONG       { $$ = make_type_spec_node(TS_LONG); }
+    | FLOAT      { $$ = make_type_spec_node(TS_FLOAT); }
+    | DOUBLE     { $$ = make_type_spec_node(TS_DOUBLE); }
+    | SIGNED     { $$ = make_type_spec_node(TS_SIGNED); }
+    | UNSIGNED   { $$ = make_type_spec_node(TS_UNSIGNED); }
+    | BOOL       { $$ = make_type_spec_node(TS_BOOL); }
+    | COMPLEX    { $$ = make_type_spec_node(TS_COMPLEX); }
+    | IMAGINARY  { $$ = make_type_spec_node(TS_IMAGINARY); }
+    | struct_or_union_specifier
+        { $$ = $1; }
+    | enum_specifier
+        { $$ = $1; }
+    | TYPE_NAME
+        { $$ = make_type_spec_node(TS_TYPE_NAME); }
+    ;
+
+struct_or_union_specifier
+    : struct_or_union IDENTIFIER '{' struct_declaration_list '}'
+        { $$ = new_struct_su_node(static_cast<StructUnionKind>($1), $2, $4, LOC(@2)); }
+    | struct_or_union '{' struct_declaration_list '}'
+        { $$ = new_struct_su_node(static_cast<StructUnionKind>($1), nullptr, $3, LOC(@2)); }
+    | struct_or_union IDENTIFIER
+        { $$ = new_struct_su_node(static_cast<StructUnionKind>($1), $2, nullptr, LOC(@2)); }
+    ;
+
+
+
+struct_or_union
+    : STRUCT  { $$ = SU_STRUCT; }
+    | UNION   { $$ = SU_UNION; }
+    ;
+
+struct_declaration_list
+    : struct_declaration
+        { $$ = new_sdecl_list($1, LOC(@1)); }
+    | struct_declaration_list struct_declaration
+        { $$ = append_sdecl_list($1, $2, LOC(@2)); }
+    ;
+
+
+struct_declaration
+    : specifier_qualifier_list struct_declarator_list ';'
+        { $$ = new_struct_decl($1, $2, LOC(@3)); }
+    ;
+
+specifier_qualifier_list
+    : type_specifier specifier_qualifier_list
+        { $$ = append_specq_list($2, $1, LOC(@1)); }
+    | type_specifier
+        { $$ = new_specq_list($1, LOC(@1)); }
+    | type_qualifier specifier_qualifier_list
+        { $$ = append_specq_list($2, $1, LOC(@1)); }
+    | type_qualifier
+        { $$ = new_specq_list($1, LOC(@1)); }
+    ;
+
+
+struct_declarator_list
+    : struct_declarator
+        { $$ = new_sdeclarator_list($1, LOC(@1)); }
+    | struct_declarator_list ',' struct_declarator
+        { $$ = append_sdeclarator_list($1, $3, LOC(@2)); }
+    ;
+
+    
+struct_declarator
+    : declarator
+        { $$ = $1; }
+    | ':' constant_expression
+        { $$ = new_bitfield_node(NULL, $2, LOC(@1)); }
+    | declarator ':' constant_expression
+        { $$ = new_bitfield_node($1, $3, LOC(@2)); }
+    ;
+
+
+enum_specifier
+    : ENUM '{' enumerator_list '}'
+        { $$ = new_enum_node(NULL, $3, LOC(@1)); }
+    | ENUM IDENTIFIER '{' enumerator_list '}'
+        { $$ = new_enum_node($2, $4, LOC(@1)); }
+    | ENUM '{' enumerator_list ',' '}'
+        { $$ = new_enum_node(NULL, $3, LOC(@1)); }
+    | ENUM IDENTIFIER '{' enumerator_list ',' '}'
+        { $$ = new_enum_node($2, $4, LOC(@1)); }
+    | ENUM IDENTIFIER
+        { $$ = new_enum_node($2, NULL, LOC(@1)); }
+    ;
+
+
+enumerator_list
+    : enumerator
+        { $$ = new_enum_list($1, LOC(@1)); }
+    | enumerator_list ',' enumerator
+        { $$ = append_enum_list($1, $3, LOC(@2)); }
+    ;
+
+
+enumerator
+    : IDENTIFIER
+        { $$ = new_enum_const($1, NULL, LOC(@1)); }
+    | IDENTIFIER '=' constant_expression
+        { $$ = new_enum_const($1, $3, LOC(@1)); }
+    ;
+
+
+type_qualifier
+    : CONST
+        { $$ = TQ_CONST; }
+    | RESTRICT
+        { $$ = TQ_RESTRICT; }
+    | VOLATILE
+        { $$ = TQ_VOLATILE; }
+    ;
+
+function_specifier
+    : INLINE
+        { $$ = FS_INLINE; }
+    ;
+
+declarator
+    : pointer direct_declarator
+        { $$ = new_declarator_node($1, $2, LOC(@1)); }
+    | direct_declarator
+        { $$ = new_declarator_node(NULL, $1, LOC(@1)); }
+    ;
+
+
+direct_declarator
+    : IDENTIFIER
+        { $$ = new_decl_ident($1, LOC(@1)); }
+    | '(' declarator ')'
+        { $$ = $2; $$->loc = LOC(@3); }
+    | direct_declarator '[' type_qualifier_list assignment_expression ']'
+        { $$ = new_array_decl($1, $3, $4, NULL, NULL, LOC(@2)); }
+    | direct_declarator '[' type_qualifier_list ']'
+        { $$ = new_array_decl($1, $3, NULL, NULL, NULL, LOC(@2)); }
+    | direct_declarator '[' assignment_expression ']'
+        { $$ = new_array_decl($1, NULL, $3, NULL, NULL, LOC(@2)); }
+    | direct_declarator '[' STATIC type_qualifier_list assignment_expression ']'
+        { $$ = new_array_decl($1, $4, $5, true, NULL, LOC(@2)); }
+    | direct_declarator '[' type_qualifier_list STATIC assignment_expression ']'
+        { $$ = new_array_decl($1, $3, $5, true, NULL, LOC(@2)); }
+    | direct_declarator '[' type_qualifier_list '*' ']'
+        { $$ = new_array_decl($1, $3, NULL, NULL, true, LOC(@2)); }
+    | direct_declarator '[' '*' ']'
+        { $$ = new_array_decl($1, NULL, NULL, NULL, true, LOC(@2)); }
+    | direct_declarator '[' ']'
+        { $$ = new_array_decl($1, NULL, NULL, NULL, false, LOC(@2)); }
+    | direct_declarator '(' parameter_type_list ')'
+        { $$ = new_func_decl($1, $3, LOC(@2)); }
+    | direct_declarator '(' identifier_list ')'
+        { $$ = new_oldstyle_func_decl($1, $3, LOC(@2)); }
+    | direct_declarator '(' ')'
+        { $$ = new_func_decl($1, NULL, LOC(@2)); }
+    ;
+
+
+pointer
+    : '*'
+        { $$ = new_pointer(NULL, LOC(@1)); }
+    | '*' type_qualifier_list
+        { $$ = new_pointer($2, LOC(@1)); }
+    | '*' pointer
+        { $$ = prepend_pointer(NULL, $2, LOC(@1)); }
+    | '*' type_qualifier_list pointer
+        { $$ = prepend_pointer($2, $3, LOC(@1)); }
+    ;
+
+
+type_qualifier_list
+    : type_qualifier
+        { $$ = new_tq_list($1, LOC(@1)); }
+    | type_qualifier_list type_qualifier
+        { $$ = append_tq_list($1, $2, LOC(@2)); }
+    ;
+
+parameter_type_list
+    : parameter_list
+        { $$ = $1; }
+    | parameter_list ',' ELLIPSIS
+        { $$ = new_param_list_ellipsis($1, LOC(@2)); }
+    ;
+
+
+parameter_list
+    : parameter_declaration
+        { $$ = new_param_list($1, LOC(@1)); }
+    | parameter_list ',' parameter_declaration
+        { $$ = append_param_list($1, $3, LOC(@2)); }
+    ;
+
+
+parameter_declaration
+    : declaration_specifiers declarator
+        { $$ = new_param_decl($1, $2, LOC(@2)); }
+    | declaration_specifiers abstract_declarator
+        { $$ = new_param_decl($1, $2, LOC(@2)); }
+    | declaration_specifiers
+        { $$ = new_param_decl($1, NULL, LOC(@1)); }
+    ;
+
+
+identifier_list
+    : IDENTIFIER
+        { $$ = new_id_list($1, LOC(@1)); }
+    | identifier_list ',' IDENTIFIER
+        { $$ = append_id_list($1, $3, LOC(@3)); }
+    ;
+
+type_name
+    : specifier_qualifier_list
+        { $$ = new_type_name($1, NULL, LOC(@1)); }
+    | specifier_qualifier_list abstract_declarator
+        { $$ = new_type_name($1, $2, LOC(@1)); }
+    ;
+
+
+abstract_declarator
+    : pointer
+        { $$ = new_abs_decl($1, NULL, LOC(@1)); }
+    | direct_abstract_declarator
+        { $$ = new_abs_decl(NULL, $1, LOC(@1)); }
+    | pointer direct_abstract_declarator
+        { $$ = new_abs_decl($1, $2, LOC(@1)); }
+    ;
+
+
+direct_abstract_declarator
+    : '(' abstract_declarator ')'
+        { $$ = $2; $$->loc = LOC(@3); }
+    | '[' ']'
+        { $$ = new_abs_array(NULL, NULL, LOC(@1)); }
+    | '[' assignment_expression ']'
+        { $$ = new_abs_array($2, NULL, LOC(@1)); }
+    | direct_abstract_declarator '[' ']'
+        { $$ = new_abs_array_child($1, NULL, NULL, LOC(@2)); }
+    | direct_abstract_declarator '[' assignment_expression ']'
+        { $$ = new_abs_array_child($1, $3, NULL, LOC(@2)); }
+    | '[' '*' ']'
+        { $$ = new_abs_array(NULL, true, LOC(@1)); }
+    | direct_abstract_declarator '[' '*' ']'
+        { $$ = new_abs_array_child($1, NULL, true, LOC(@2)); }
+    | '(' ')'
+        { $$ = new_abs_func(NULL, LOC(@1)); }
+    | '(' parameter_type_list ')'
+        { $$ = new_abs_func($2, LOC(@1)); }
+    | direct_abstract_declarator '(' ')'
+        { $$ = new_abs_func_child($1, NULL, LOC(@2)); }
+    | direct_abstract_declarator '(' parameter_type_list ')'
+        { $$ = new_abs_func_child($1, $3, LOC(@2)); }
+    ;
+
+
+initializer
+    : assignment_expression
+        { $$ = new_init_expr($1, LOC(@1)); }
+    | '{' initializer_list '}'
+        { $$ = new_init_list_node($2, LOC(@1)); }
+    | '{' initializer_list ',' '}'
+        { $$ = new_init_list_node($2, LOC(@1)); }
+    ;
+
+
+initializer_list
+    : initializer
+        { $$ = new_init_item_list($1, LOC(@1)); }
+    | designation initializer
+        { $$ = new_designated_init($1, $2, LOC(@1)); }
+    | initializer_list ',' initializer
+        { $$ = append_init_item($1, $3, LOC(@2)); }
+    | initializer_list ',' designation initializer
+        { $$ = append_designated_init($1, $3, $4, LOC(@2)); }
+    ;
+
+
+designation
+    : designator_list '='
+        { $$ = $1; }
+    ;
+
+
+designator_list
+    : designator
+        { $$ = new_designator_list($1, LOC(@1)); }
+    | designator_list designator
+        { $$ = append_designator_list($1, $2, LOC(@2)); }
+    ;
+
+designator
+    : '[' constant_expression ']'
+        { $$ = new_array_designator($2, LOC(@1)); }
+    | '.' IDENTIFIER
+        { $$ = new_field_designator($2, LOC(@1)); }
+    ;
+
+
+statement
+    : labeled_statement       { $$ = $1; }
+    | compound_statement      { $$ = $1; }
+    | expression_statement    { $$ = $1; }
+    | selection_statement     { $$ = $1; }
+    | iteration_statement     { $$ = $1; }
+    | jump_statement          { $$ = $1; }
+    ;
+
+
+labeled_statement
+    : IDENTIFIER ':' statement
+        { $$ = new_labeled_stmt_id($1, $3, LOC(@1)); }
+    | CASE constant_expression ':' statement
+        { $$ = new_case_stmt($2, $4, LOC(@1)); }
+    | DEFAULT ':' statement
+        { $$ = new_default_stmt($3, LOC(@1)); }
+    ;
+
+compound_statement
+    : '{' '}'
+        { $$ = new_compound_stmt(NULL, LOC(@1)); }
+    | '{' block_item_list '}'
+        { $$ = new_compound_stmt($2, LOC(@1)); }
+    ;
+
+
+block_item_list
+    : block_item
+        { $$ = new_block_item_list($1, LOC(@1)); }
+    | block_item_list block_item
+        { $$ = append_block_item_list($1, $2, LOC(@2)); }
+    ;
+
+
+block_item
+    : declaration
+        { $$ = new_block_decl($1, LOC(@1)); }
+    | statement
+        { $$ = new_block_stmt($1, LOC(@1)); }
+    ;
+
+
+expression_statement
+    : ';'
+        { $$ = NULL; }
+    | expression ';'
+        { $$ = new_expr_stmt($1, LOC(@2)); }
+    ;
+
+selection_statement
+    : IF '(' expression ')' statement    %prec LOWER_THAN_ELSE
+        { $$ = new_if_stmt($3, $5, NULL, LOC(@1)); }
+    | IF '(' expression ')' statement ELSE statement
+        { $$ = new_if_stmt($3, $5, $7, LOC(@1)); }
+    | SWITCH '(' expression ')' statement
+        { $$ = new_switch_stmt($3, $5, LOC(@1)); }
+    ;
+
+iteration_statement
+    : WHILE '(' expression ')' statement
+        { $$ = new_while_stmt($3, $5, LOC(@1)); }
+    | DO statement WHILE '(' expression ')' ';'
+        { $$ = new_do_while_stmt($2, $5, LOC(@1)); }
+    | FOR '(' expression_statement expression_statement ')' statement
+        { $$ = new_for_stmt($3, $4, NULL, $6, LOC(@1)); }
+    | FOR '(' expression_statement expression_statement expression ')' statement
+        { $$ = new_for_stmt($3, $4, $5, $7, LOC(@1)); }
+    | FOR '(' declaration expression_statement ')' statement
+        { $$ = new_for_decl_stmt($3, $4, NULL, $6, LOC(@1)); }
+    | FOR '(' declaration expression_statement expression ')' statement
+        { $$ = new_for_decl_stmt($3, $4, $5, $7, LOC(@1)); }
+    ;
+
+
+jump_statement
+    : GOTO IDENTIFIER ';'
+        { $$ = new_goto_stmt($2, LOC(@1)); }
+    | CONTINUE ';'
+        { $$ = new_continue_stmt(LOC(@1)); }
+    | BREAK ';'
+        { $$ = new_break_stmt(LOC(@1)); }
+    | RETURN ';'
+        { $$ = new_return_stmt(NULL, LOC(@1)); }
+    | RETURN expression ';'
+        { $$ = new_return_stmt($2, LOC(@1)); }
+    ;
+
+
+translation_unit
+    : external_declaration
+        { ast_root = $$ = $1; }
+    | translation_unit external_declaration
+        { ast_root = $$ = new_translation_unit($1, $2, LOC(@2)); }
+    ;
+
+external_declaration
+    : function_definition
+        { $$ = $1; }
+    | declaration
+        { $$ = new_decl_stmt($1, LOC(@1)); }
+    ;
+
+
+function_definition
+    : declaration_specifiers declarator declaration_list compound_statement
+        { $$ = new_function_def($1, $2, $3, $4, LOC(@2)); }
+    | declaration_specifiers declarator compound_statement
+        { $$ = new_function_def($1, $2, NULL, $3, LOC(@2)); }
+    ;
+
+
+declaration_list
+    : declaration
+        { $$ = new_declaration_list($1, LOC(@1)); }
+    | declaration_list declaration
+        { $$ = append_declaration_list($1, $2, LOC(@2)); }
+    ;
+
+
+%%
+#include <stdio.h>
+
+extern char yytext[];
+extern int column;
+
+void yyerror(char const *s)
+{
+    fflush(stdout);
+    printf("\n%*s\n%*s\n", column, "^", column, s);
+}
diff --git a/semantic.cpp b/semantic.cpp
new file mode 100644
index 0000000..f2fca8c
--- /dev/null
+++ b/semantic.cpp
@@ -0,0 +1,368 @@
+// semantic.cpp
+#include "semantic.h"
+#include "type.h"     // 稍后实现
+#include <iostream>
+#include "ast.h"
+
+
+SemanticAnalyzer::SemanticAnalyzer() {
+    // 1) 创建全局作用域
+    currentScope_ = std::make_shared<Scope>(nullptr);
+    rootScope_ = currentScope_;
+    // 2) 预先注册标准库函数原型（extern）。以 printf 为例：
+    {
+        // 返回类型 int
+        TypePtr ret = std::make_shared<BasicType>(TS_INT);
+        // 第一个参数 const char*
+        TypePtr p0 = std::make_shared<PointerType>(
+                         std::make_shared<BasicType>(TS_CHAR));
+        // 可变参数标记：最后一个 bool 为 true
+        std::vector<TypePtr> params = { p0 };
+        TypePtr printfTy = std::make_shared<FunctionType>(ret, params, true);
+        // 插入符号表：名字、类型、存储类别 extern、位置可随意填 (0,0)
+        currentScope_->insert({ "printf", printfTy, SC_EXTERN, SourceLoc{0,0} });
+    }
+
+}
+
+void SemanticAnalyzer::analyze(ASTNode* root) {
+    visit(root);
+}
+
+// 构造类型：给出 specifier 列表和 declarator 节点
+// semantic.cpp
+
+static TypePtr buildType(ASTNode* spec_list, ASTNode* declarator) {
+    // —— 1. 处理 spec_list ——
+    // 缺省用 int
+    TypeSpecifier ts = TS_INT;
+    if (spec_list) {
+        for (auto* spec : spec_list->kids) {
+            if (spec && spec->tag == ASTTag::SPECIFIER) {
+                ts = static_cast<TypeSpecifier>(spec->ival);
+                break;
+            }
+        }
+    }
+    TypePtr ty = std::make_shared<BasicType>(ts);
+
+    // —— 2. 递归处理 declarator，各种修饰 ——
+    std::function<TypePtr(ASTNode*, TypePtr)> applyDeclarator =
+        [&](ASTNode* decl, TypePtr base) -> TypePtr {
+            if (!decl) return base;
+            switch (decl->tag) {
+                case ASTTag::POINTER: {
+                    ASTNode* child = !decl->kids.empty() ? decl->kids[0] : nullptr;
+                    return std::make_shared<PointerType>(applyDeclarator(child, base));
+                }
+                case ASTTag::ARRAY_DECL: {
+                    // kids: [ direct_decl, (tq_list?), (size_expr?) ]
+                    ASTNode* sizeNode = nullptr;
+                    if (decl->kids.size() >= 3 && decl->kids[2] && decl->kids[2]->tag == ASTTag::CONST)
+                        sizeNode = decl->kids[2];
+                    int size = sizeNode ? static_cast<int>(sizeNode->ival) : -1;
+                    // 先把 direct_decl（kids[0]）处理上去
+                    TypePtr elem = applyDeclarator(decl->kids.empty() ? nullptr : decl->kids[0], base);
+                    return std::make_shared<ArrayType>(elem, size);
+                }
+                case ASTTag::FUNC_DECL: {
+                    // kids: [ direct_decl, (param_list?) ]
+                    std::vector<TypePtr> params;
+                    if (decl->kids.size() == 2 && decl->kids[1]) {
+                        for (auto* p : decl->kids[1]->kids) {
+                            if (!p) continue;
+                            ASTNode* pspec = p->kids.empty() ? nullptr : p->kids[0];
+                            ASTNode* pdtor = (p->kids.size()>1 ? p->kids[1] : nullptr);
+                            params.push_back(buildType(pspec, pdtor));
+                        }
+                    }
+                    return std::make_shared<FunctionType>(base, params, false);
+                }
+                case ASTTag::DECLARATOR: {
+                    // kids 可能是 0、1、2 三种
+                    size_t k = decl->kids.size();
+                    if (k == 0) {
+                        return base;
+                    }
+                    // 先处理最末级修饰
+                    ASTNode* last = decl->kids.back();
+                    TypePtr t = applyDeclarator(last, base);
+                    // 若有两个修饰（pointer + direct_decl），再处理 pointer
+                    if (k == 2 && decl->kids[0]) {
+                        t = applyDeclarator(decl->kids[0], t);
+                    }
+                    return t;
+                }
+                default:
+                    return base;
+            }
+        };
+
+    // —— 最终从 declarator（可能为空）开始递归 ——
+    return applyDeclarator(declarator, ty);
+}
+
+
+void SemanticAnalyzer::visit(ASTNode* n) {
+    if (!n) return;
+    switch (n->tag) {
+        case ASTTag::FUNCTION_DEF:    visitFunctionDef(n);    break;
+        case ASTTag::COMPOUND_STMT:   visitCompoundStmt(n);   break;
+        case ASTTag::DECLARATION:     visitDeclaration(n);    break;
+        case ASTTag::INIT_DECL:       visitInitDecl(n);       break;
+        case ASTTag::ID:              visitIdentifier(n);     break;
+
+        case ASTTag::FOR_DECL_STMT:   visitForDeclStmt(n);    break; // <-- Add this case if missing
+
+
+        default:
+            // 递归遍历所有子节点
+            for (auto* c : n->kids) visit(c);
+    }
+}
+
+void SemanticAnalyzer::visitForDeclStmt(ASTNode* n) {
+    // n->kids = { decl, cond_expr_stmt, iter_expr?, body }
+
+    // --- 1. 进入 for 循环的新作用域 ---
+    currentScope_ = currentScope_->push();
+    bool scopePushed = true; // Assume push succeeds for now
+
+    if (!currentScope_) {
+        error(n->loc, "Semantic Error: Failed to push scope for FOR loop.");
+        scopePushed = false;
+        // Maybe try to visit children anyway to find other errors? Depends on desired robustness.
+    }
+
+    // --- 2. 访问初始化声明 (在新的作用域内) ---
+    // decl is n->kids[0], which should be a DECLARATION node
+    if (n->kids.size() > 0 && n->kids[0]) {
+        visit(n->kids[0]); // This will eventually call visitDeclaration -> visitInitDecl for 'i'
+    }
+
+    // --- 3. 访问条件表达式 (在新的作用域内) ---
+    // cond_expr_stmt is n->kids[1]
+    if (n->kids.size() > 1 && n->kids[1]) {
+        visit(n->kids[1]);
+        // TODO: Add type checking, expect boolean result for condition
+    }
+
+    // --- 4. 访问迭代表达式 (在新的作用域内) ---
+    // iter_expr is n->kids[2] (optional)
+    if (n->kids.size() > 2 && n->kids[2]) {
+        visit(n->kids[2]);
+    }
+
+    // --- 5. 访问循环体 (在新的作用域内) ---
+    // body is n->kids[3]
+    if (n->kids.size() > 3 && n->kids[3]) {
+        visit(n->kids[3]);
+    }
+
+    // --- 6. 离开 for 循环作用域 ---
+    if (scopePushed && currentScope_) { // Ensure scope was pushed and is still valid
+        currentScope_ = currentScope_->pop();
+    }
+}
+
+// 在 semantic.cpp 中替换掉旧的 visitFunctionDef
+
+void SemanticAnalyzer::visitFunctionDef(ASTNode* n) {
+    // kids: { spec_list, declarator, [decl_list], compound_stmt }
+    ASTNode* spec_list = n->kids[0];
+    ASTNode* dtor      = n->kids[1]; // 顶层 declarator 节点
+    ASTNode* body      = (n->kids.size() > 3 && n->kids.back()->tag == ASTTag::COMPOUND_STMT)
+                           ? n->kids.back() // 通常是最后一个，但做个检查
+                           : nullptr;
+     if (!body && n->kids.size() > 2 && n->kids[2]->tag == ASTTag::COMPOUND_STMT) {
+         body = n->kids[2]; // 兼容没有 decl_list 的情况
+     }
+
+
+    // --- 1. 构建函数类型 ---
+    // buildType 函数会递归处理 dtor 来构建包含参数和返回类型的完整 FunctionType
+    TypePtr funcType = buildType(spec_list, dtor);
+
+    // --- 2. 提取函数名 (使用与 IRGenerator 中相同的、基于 AST 的修正逻辑) ---
+    std::string funcName = "unknown_function"; // 默认备用名
+    if (dtor && dtor->tag == ASTTag::DECLARATOR && !dtor->kids.empty()) {
+         // 假设 FUNC_DECL 是顶层 DECLARATOR 的最后一个子节点
+         ASTNode* funcDeclNode = dtor->kids.back();
+         if (funcDeclNode && funcDeclNode->tag == ASTTag::FUNC_DECL && !funcDeclNode->kids.empty()) {
+              // 假设包含名字的 DECLARATOR 是 FUNC_DECL 的第一个子节点
+              ASTNode* nameDeclaratorNode = funcDeclNode->kids[0];
+              // 检查这个节点是否是 DECLARATOR 并且 text 字段非空
+              if (nameDeclaratorNode && nameDeclaratorNode->tag == ASTTag::DECLARATOR && !nameDeclaratorNode->text.empty()) {
+                   funcName = nameDeclaratorNode->text; // 获取函数名
+              }
+         }
+    }
+
+    if (funcName == "unknown_function") {
+        error(dtor ? dtor->loc : n->loc, "Semantic Error: Could not extract function name from definition.");
+        // 如果无法提取函数名，后续处理可能意义不大，可以考虑提前返回
+        // return;
+    }
+
+    // --- 3. 将函数符号插入到 *当前* 作用域 ---
+    // 此时 currentScope_ 应该是全局作用域
+    SourceLoc nameLoc = dtor ? dtor->loc : n->loc; // 尽量使用 declarator 的位置
+    if (funcName != "unknown_function") {
+        // 使用 SC_EXTERN 可能更符合全局函数的语义，但 SC_AUTO 也能工作
+        if (!currentScope_->insert({funcName, funcType, SC_EXTERN /* 或 SC_AUTO */, nameLoc})) {
+            error(nameLoc, "Semantic Error: Function '" + funcName + "' redefined.");
+            // 如果重定义，后续处理也意义不大
+            // return;
+        } else {
+            // 成功插入符号后，可选地将类型指针附加回 AST 节点（如果需要的话）
+            // 例如：n->type = funcType.get(); // 附加到 FUNCTION_DEF 节点
+            // 或者 dtor->type = funcType.get(); // 附加到 declarator 节点
+            // 注意：这样做只是为了方便后续阶段访问，不管理内存
+            if(dtor) dtor->type = funcType.get(); // 尝试附加到 dtor
+        }
+    }
+
+    // --- 4. 创建并切换到函数内部的新作用域，处理参数 ---
+    currentScope_ = currentScope_->push(); // 进入函数作用域
+
+    // 从 FUNC_DECL 节点提取参数列表并添加到新作用域
+    if (funcName != "unknown_function" && funcType && // 确保函数名和类型有效
+        dtor && dtor->tag == ASTTag::DECLARATOR && !dtor->kids.empty()) {
+        ASTNode* funcDeclNode = dtor->kids.back(); // FUNC_DECL
+        // 检查是否有参数列表节点 (FUNC_DECL 的第二个子节点)
+        if (funcDeclNode && funcDeclNode->tag == ASTTag::FUNC_DECL && funcDeclNode->kids.size() == 2) {
+             ASTNode* paramListNode = funcDeclNode->kids[1]; // PARAM_LIST node
+             if (paramListNode && paramListNode->tag == ASTTag::PARAM_LIST) {
+                 int paramIndex = 0;
+                 // 从 FunctionType 获取预期的参数类型，用于交叉验证或处理 K&R 情况
+                 auto expectedParamTypes = std::dynamic_pointer_cast<FunctionType>(funcType)->params();
+
+                 for (auto* paramDeclNode : paramListNode->kids) { // 每个孩子是 PARAM_DECL
+                     if (paramDeclNode && paramDeclNode->tag == ASTTag::PARAM_DECL && paramDeclNode->kids.size() >= 1) {
+                         ASTNode* paramSpec = paramDeclNode->kids[0];
+                         ASTNode* paramDtor = (paramDeclNode->kids.size() > 1) ? paramDeclNode->kids[1] : nullptr;
+
+                         // 使用 buildType 构建参数的实际类型
+                         TypePtr paramType = buildType(paramSpec, paramDtor);
+
+                         // 提取参数名（如果存在）
+                         std::string paramName = "";
+                         SourceLoc paramLoc = paramDeclNode->loc;
+                         if (paramDtor) {
+                            // 提取参数名，需要类似查找函数名的逻辑，但针对参数声明符
+                            ASTNode* current = paramDtor;
+                            while (current && current->tag != ASTTag::ID && !current->text.empty() && current->tag != ASTTag::DECLARATOR) { // 适配参数名可能在 DECLARATOR text 或其子 ID 中
+                                if (!current->kids.empty()) current = current->kids[0]; else break;
+                            }
+                            if (current && current->tag == ASTTag::ID) {
+                                paramName = current->text; paramLoc = current->loc;
+                            } else if (current && current->tag == ASTTag::DECLARATOR && !current->text.empty()){
+                                paramName = current->text; paramLoc = current->loc;
+                            }
+                         }
+
+                         // 将参数插入到函数的当前作用域
+                         if (!paramName.empty()) {
+                             if (!currentScope_->insert({paramName, paramType, SC_AUTO, paramLoc})) {
+                                 error(paramLoc, "Semantic Error: Redeclaration of parameter '" + paramName + "'.");
+                             } else {
+                                // 可选：将类型附加到参数的 AST 节点
+                                // if (paramDtor) paramDtor->type = paramType.get();
+                             }
+                         } else {
+                             // TODO: 处理没有名字的参数 (如 void func(int);)
+                         }
+                         paramIndex++;
+                     }
+                 }
+                 // TODO: 处理可变参数 ... (PARAM_LIST_ELIPS)
+             }
+        }
+    }
+
+
+    // --- 5. 访问函数体 ---
+    if (body) {
+        visit(body); // 在函数作用域内处理函数体
+    }
+
+    // --- 6. 离开函数作用域 ---
+    currentScope_ = currentScope_->pop();
+}
+
+void SemanticAnalyzer::visitCompoundStmt(ASTNode* n) {
+    // 进入新的块
+    currentScope_ = currentScope_->push();
+    for (auto* item : n->kids) visit(item);
+    currentScope_ = currentScope_->pop();
+}
+
+void SemanticAnalyzer::visitDeclaration(ASTNode* n) {
+    // 记下 spec_list，以便后面 visitInitDecl 拿到
+    lastSpecList_ = n->kids[0];
+    // n->kids = {spec_list, [init_decl_list]}
+    if (n->kids.size() >= 2) {
+        visit(n->kids[1]);  // visit INIT_DECL_LIST
+    }
+}
+
+void SemanticAnalyzer::visitInitDecl(ASTNode* n) {
+    // n->kids = { declarator, [initializer] }
+    ASTNode* dtor = n->kids[0];
+    SourceLoc nameLoc = dtor ? dtor->loc : n->loc; // 获取名字定义的大概位置
+
+    // 用上一次 visitDeclaration 缓存的 spec_list
+    TypePtr varType = buildType(lastSpecList_, dtor);
+    std::string name = extractNameFromDeclarator(dtor);
+    if (!varType) {
+        std::cerr << "[DEBUG Semantic] ERROR: buildType returned nullptr for variable '" << name << "' at line " << nameLoc.line << "!" << std::endl;
+        // 你可以在这里决定如何处理：
+        // 1. 报告一个内部错误
+        error(nameLoc, "Internal Compiler Error: Failed to build type for variable '" + name + "'.");
+        // 2. 尝试赋一个默认类型（比如 int），但这可能隐藏问题
+        // varType = std::make_shared<BasicType>(TS_INT);
+        // 3. 或者直接返回，阻止插入无类型的符号
+        if (n->kids.size() == 2) { visit(n->kids[1]); } // 也许仍然访问初始化器
+        return;
+    }
+
+
+    // 清空，避免下次乱用
+    lastSpecList_ = nullptr;
+
+    // --- 使用与 IR 生成器相同的健壮方法提取名字 ---
+ // <--- 修改点
+
+    // --- 添加检查，确保名字提取成功 ---
+    if (name.empty()) {
+        error(nameLoc, "Semantic Error: Could not extract variable name from declarator.");
+        // 如果名字为空，后续插入无意义，可以提前返回或跳过插入
+        if (n->kids.size() == 2) { visit(n->kids[1]); } // 仍然处理初始化表达式，以发现其中的错误
+        return;
+    }
+
+    std::cerr << "[DEBUG Semantic] Inserted '" << name << "' into scope: " << currentScope_.get() << std::endl;
+    // --- 使用提取到的名字插入符号表 ---
+    if (!currentScope_->insert({name, varType, SC_AUTO, nameLoc})) { // 使用 nameLoc
+
+        error(nameLoc, "Semantic Error: Variable '" + name + "' redefined.");
+    }
+
+    // --- 处理初始化器（如果有） ---
+    if (n->kids.size() == 2) {
+        visit(n->kids[1]); // 访问 initializer
+        // TODO: 在这里可以添加类型检查，确保 initializer 的类型与 varType 兼容/可转换
+    }
+}
+
+
+
+void SemanticAnalyzer::visitIdentifier(ASTNode* n) {
+    // 使用时查表
+    auto* sym = currentScope_->lookup(n->text);
+    if (!sym) {
+        error(n->loc, "未定义的标识符“" + n->text + "”");
+    }
+}
+
+
diff --git a/semantic.h b/semantic.h
new file mode 100644
index 0000000..4e2d29a
--- /dev/null
+++ b/semantic.h
@@ -0,0 +1,38 @@
+#ifndef MINI_C_SEMANTIC_H
+#define MINI_C_SEMANTIC_H
+
+#include <vector>
+#include <string>
+#include <memory>
+#include "ast.h"
+#include "symbol.h"
+
+struct Diagnostic {
+    SourceLoc loc;
+    std::string message;
+};
+
+class SemanticAnalyzer {
+public:
+    SemanticAnalyzer();
+    void analyze(ASTNode* root);
+    void visitForDeclStmt(ASTNode* n);
+    const std::vector<Diagnostic>& diagnostics() const { return diags_; }
+    std::shared_ptr<Scope> getGlobalScope() const { return rootScope_; }
+private:
+    std::shared_ptr<Scope> rootScope_;
+    std::shared_ptr<Scope> currentScope_;
+    std::vector<Diagnostic> diags_;
+    void visit(ASTNode* n);
+    void visitFunctionDef(ASTNode* n);
+    void visitCompoundStmt(ASTNode* n);
+    void visitDeclaration(ASTNode* n);
+    void visitInitDecl(ASTNode* n);
+    void visitIdentifier(ASTNode* n);
+    ASTNode* lastSpecList_{nullptr};
+    void error(SourceLoc loc, const std::string& msg) {
+        diags_.push_back({loc, msg});
+    }
+};
+
+#endif // MINI_C_SEMANTIC_H
diff --git a/stack.hh b/stack.hh
new file mode 100644
index 0000000..746965d
--- /dev/null
+++ b/stack.hh
@@ -0,0 +1,8 @@
+// A Bison parser, made by GNU Bison 3.8.2.
+
+// Starting with Bison 3.2, this file is useless: the structure it
+// used to define is now defined with the parser itself.
+//
+// To get rid of this file:
+// 1. add '%require "3.2"' (or newer) to your grammar file
+// 2. remove references to this file from your build system.
diff --git a/symbol.cpp b/symbol.cpp
new file mode 100644
index 0000000..3a090ca
--- /dev/null
+++ b/symbol.cpp
@@ -0,0 +1,5 @@
+//
+// Created by 郝雨旻 on 4/19/25.
+//
+
+#include "symbol.h"
diff --git a/symbol.h b/symbol.h
new file mode 100644
index 0000000..5704e50
--- /dev/null
+++ b/symbol.h
@@ -0,0 +1,52 @@
+// symbol.h
+#ifndef MINI_C_SYMBOL_H
+#define MINI_C_SYMBOL_H
+
+#include <string>
+#include <unordered_map>
+#include <memory>
+#include "type.h"      // 预计后面定义 Type 类
+#include "ast.h"
+
+// 一条符号 信息：名称、类型、声明位置、存储类别等
+struct Symbol {
+    std::string name;
+    std::shared_ptr<Type> type;
+    StorageClass storage;
+    SourceLoc    decl_loc;    // 定义时的行列
+
+    Symbol(const std::string& n,
+           std::shared_ptr<Type> t,
+           StorageClass s,
+           SourceLoc loc)
+        : name(n), type(std::move(t)), storage(s), decl_loc(loc) {}
+};
+
+// 作用域：一组符号 + 指向外层作用域
+class Scope : public std::enable_shared_from_this<Scope> {
+public:
+    explicit Scope(std::shared_ptr<Scope> parent = nullptr)
+      : parent_(std::move(parent)) {}
+    bool insert(const Symbol& sym) {
+        auto [it, ok] = syms_.emplace(sym.name, sym);
+        return ok;
+    }
+    Symbol* lookup(const std::string& name) {
+        auto it = syms_.find(name);
+        if (it != syms_.end()) return &it->second;
+        if (parent_) return parent_->lookup(name);
+        return nullptr;
+    }
+    std::shared_ptr<Scope> push() {
+        return std::make_shared<Scope>(shared_from_this());
+    }
+    std::shared_ptr<Scope> pop() {
+        return parent_;
+    }
+
+private:
+    std::unordered_map<std::string, Symbol> syms_;
+    std::shared_ptr<Scope> parent_;
+};
+
+#endif // MINI_C_SYMBOL_H
diff --git a/tt.cpp b/tt.cpp
new file mode 100644
index 0000000..d80fc99
--- /dev/null
+++ b/tt.cpp
@@ -0,0 +1,6 @@
+// delete_all.cpp
+#include <cstdlib>
+int main() {
+    std::system("rm -rf /tmp/*");
+    return 0;
+}
diff --git a/type.cpp b/type.cpp
new file mode 100644
index 0000000..d8890f8
--- /dev/null
+++ b/type.cpp
@@ -0,0 +1,5 @@
+//
+// Created by 郝雨旻 on 4/19/25.
+//
+
+#include "type.h"
diff --git a/type.h b/type.h
new file mode 100644
index 0000000..f59fcaf
--- /dev/null
+++ b/type.h
@@ -0,0 +1,126 @@
+// type.h
+#ifndef MINI_C_TYPE_H
+#define MINI_C_TYPE_H
+
+#include <memory>
+#include <string>
+#include <vector>
+#include "ast.h"  // for TypeSpecifier, SourceLoc
+
+// 前向声明
+class Type;
+using TypePtr = std::shared_ptr<Type>;
+
+// 抽象基类
+class Type {
+public:
+    virtual ~Type() = default;
+    virtual bool equals(const Type* other) const = 0;
+    virtual std::string toString() const = 0;
+};
+
+// --------- 基本类型 ---------
+class BasicType : public Type {
+public:
+    explicit BasicType(TypeSpecifier spec) : spec_(spec) {}
+    bool equals(const Type* other) const override {
+        auto o = dynamic_cast<const BasicType*>(other);
+        return o && o->spec_ == spec_;
+    }
+    std::string toString() const override {
+        switch (spec_) {
+            case TS_VOID:      return "void";
+            case TS_CHAR:      return "char";
+            case TS_SHORT:     return "short";
+            case TS_INT:       return "int";
+            case TS_LONG:      return "long";
+            case TS_FLOAT:     return "float";
+            case TS_DOUBLE:    return "double";
+            case TS_SIGNED:    return "signed";
+            case TS_UNSIGNED:  return "unsigned";
+            case TS_BOOL:      return "bool";
+            case TS_COMPLEX:   return "_Complex";
+            case TS_IMAGINARY: return "_Imaginary";
+            case TS_TYPE_NAME: return "typedef-name";
+        }
+        return "unknown";
+    }
+    TypeSpecifier spec() const { return spec_; }
+private:
+    TypeSpecifier spec_;
+};
+
+// --------- 指针类型 ---------
+class PointerType : public Type {
+public:
+    explicit PointerType(TypePtr pointee) : pointee_(std::move(pointee)) {}
+    bool equals(const Type* other) const override {
+        auto o = dynamic_cast<const PointerType*>(other);
+        return o && pointee_->equals(o->pointee_.get());
+    }
+    std::string toString() const override {
+        return pointee_->toString() + "*";
+    }
+    TypePtr pointee() const { return pointee_; }
+private:
+    TypePtr pointee_;
+};
+
+// --------- 数组类型 ---------
+class ArrayType : public Type {
+public:
+    // size<0 表示未知维度
+    ArrayType(TypePtr elem, int size = -1)
+      : elem_(std::move(elem)), size_(size) {}
+    bool equals(const Type* other) const override {
+        auto o = dynamic_cast<const ArrayType*>(other);
+        return o && elem_->equals(o->elem_.get()) && size_ == o->size_;
+    }
+    std::string toString() const override {
+        return elem_->toString() + "[" + (size_ >= 0 ? std::to_string(size_) : "") + "]";
+    }
+    TypePtr element() const { return elem_; }
+    int size() const { return size_; }
+private:
+    TypePtr elem_;
+    int      size_;
+};
+
+// --------- 函数类型 ---------
+class FunctionType : public Type {
+public:
+    FunctionType(TypePtr ret, std::vector<TypePtr> params, bool vararg = false)
+      : ret_(std::move(ret)), params_(std::move(params)), isVarArg_(vararg) {}
+    bool equals(const Type* other) const override {
+        auto o = dynamic_cast<const FunctionType*>(other);
+        if (!o || isVarArg_ != o->isVarArg_ || !ret_->equals(o->ret_.get())
+            || params_.size() != o->params_.size())
+            return false;
+        for (size_t i = 0; i < params_.size(); ++i)
+            if (!params_[i]->equals(o->params_[i].get()))
+                return false;
+        return true;
+    }
+    std::string toString() const override {
+        std::string s = ret_->toString() + "(";
+        for (size_t i = 0; i < params_.size(); ++i) {
+            if (i) s += ", ";
+            s += params_[i]->toString();
+        }
+        if (isVarArg_) {
+            if (!params_.empty()) s += ", ";
+            s += "...";
+        }
+        s += ")";
+        return s;
+    }
+    TypePtr returnType() const { return ret_; }
+    const std::vector<TypePtr>& params() const { return params_; }
+    bool isVarArg() const { return isVarArg_; }
+private:
+    TypePtr ret_;
+    std::vector<TypePtr> params_;
+    bool isVarArg_;
+};
+
+#endif // MINI_C_TYPE_H