From d71eb4576e5dc134d94d64f36a98b6f571933ef9 Mon Sep 17 00:00:00 2001
From: hym816 <haoyumin666@outlook.com>
Date: Sun, 16 Nov 2025 21:04:02 +0800
Subject: [PATCH] =?UTF-8?q?=E3=80=902025-11-16=E3=80=91=E7=8E=B0=E6=9C=89?=
 =?UTF-8?q?=E4=BB=A3=E7=A0=81=E4=B8=8A=E4=BC=A0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 AssemblyGenerator.cpp   |  204 +++
 AssemblyGenerator.h     |   28 +
 InstructionEncoder.cpp  |  169 ++
 InstructionEncoder.h    |   61 +
 ObjectFileGenerator.cpp |  113 ++
 ObjectFileGenerator.h   |   18 +
 PrettyPrinter.cpp       |  411 +++++
 PrettyPrinter.h         |   57 +
 ast.cpp                 |  809 +++++++++
 ast.h                   |  325 ++++
 interpreter.cpp         |  364 ++++
 interpreter.h           |   41 +
 ir.cpp                  |  612 +++++++
 ir.h                    |  130 ++
 lex.yy.cpp              | 2599 ++++++++++++++++++++++++++++
 main.cpp                |  273 +++
 mini_c.l                |  210 +++
 mini_c.tab.cpp          | 3529 +++++++++++++++++++++++++++++++++++++++
 mini_c.tab.hpp          |  164 ++
 mini_c.y                |  799 +++++++++
 semantic.cpp            |  368 ++++
 semantic.h              |   38 +
 stack.hh                |    8 +
 symbol.cpp              |    5 +
 symbol.h                |   52 +
 tt.cpp                  |    6 +
 type.cpp                |    5 +
 type.h                  |  126 ++
 28 files changed, 11524 insertions(+)
 create mode 100644 AssemblyGenerator.cpp
 create mode 100644 AssemblyGenerator.h
 create mode 100644 InstructionEncoder.cpp
 create mode 100644 InstructionEncoder.h
 create mode 100644 ObjectFileGenerator.cpp
 create mode 100644 ObjectFileGenerator.h
 create mode 100644 PrettyPrinter.cpp
 create mode 100644 PrettyPrinter.h
 create mode 100644 ast.cpp
 create mode 100644 ast.h
 create mode 100644 interpreter.cpp
 create mode 100644 interpreter.h
 create mode 100644 ir.cpp
 create mode 100644 ir.h
 create mode 100644 lex.yy.cpp
 create mode 100644 main.cpp
 create mode 100644 mini_c.l
 create mode 100644 mini_c.tab.cpp
 create mode 100644 mini_c.tab.hpp
 create mode 100644 mini_c.y
 create mode 100644 semantic.cpp
 create mode 100644 semantic.h
 create mode 100644 stack.hh
 create mode 100644 symbol.cpp
 create mode 100644 symbol.h
 create mode 100644 tt.cpp
 create mode 100644 type.cpp
 create mode 100644 type.h

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