LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: JameyWoo[P]csmile/parse.cpp
// Function: param_list(TreeNode*)
TreeNode* param_list(TreeNode* k) {
    // TODO: 到这里暂停, 明天再写. 完善函数的操作
    TreeNode* t = param(k);  // 先读一个参数
    TreeNode* p = t;
    k           = NULL;
    while (ptoken.type == "Comma") {  // 如果读到逗号, 说明还有下一个参数
        match("Comma");
        TreeNode* q = param(k);
        if (q != NULL) {
            if (t == NULL) {  // ! 是否多余
                t = p = q;
            } else {
                p->sibling = q;
                p          = q;
            }
        }
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x81a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x8(%rbp)
leaq 0x25d95(%rip), %rdi     # 0x2e588
leaq 0x188f8(%rip), %rsi     # 0x210f2
callq 0x5e70
testb $0x1, %al
jne 0x8808
jmp 0x88f1
leaq -0x81(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3480
movq -0xa8(%rbp), %rdx
leaq 0x188c9(%rip), %rsi     # 0x210f2
leaq -0x80(%rbp), %rdi
callq 0x4ef0
jmp 0x8834
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x80b0
jmp 0x8843
leaq -0x60(%rbp), %rdi
callq 0x4ec0
leaq -0x80(%rbp), %rdi
callq 0x34e8
leaq -0x81(%rbp), %rdi
callq 0x32d0
movq -0x8(%rbp), %rdi
callq 0x81a0
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0xa0(%rbp)
je 0x88ec
cmpq $0x0, -0x10(%rbp)
jne 0x88d0
movq -0xa0(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x10(%rbp)
jmp 0x88ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x88c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x34e8
leaq -0x81(%rbp), %rdi
callq 0x32d0
jmp 0x88fe
movq -0xa0(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0xa0(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x88ec
jmp 0x87ec
movq -0x10(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3470
nopw (%rax,%rax)
// File: JameyWoo[P]csmile/parse.cpp
// Function: statement_list()
TreeNode* statement_list() {
    /**
     * 一系列的语句
     */
    TreeNode* t = statement();
    TreeNode* p = t;
    // 判断哪些token可以做为statement的开始
    while (ptoken.type == "if" || ptoken.type == "Id" || ptoken.type == "while" ||
           ptoken.type == "return" || ptoken.type == "semicolon" || ptoken.type == "input" ||
           ptoken.type == "output") {
        TreeNode* q;
        // cout << "ptoken.type == " << ptoken.type << endl;
        q = statement();
        if (q != NULL) {
            if (t == NULL) {
                t = p = q;
            } else {
                p->sibling = q;
                p          = q;
            }
        }
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xbda0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x24258(%rip), %rdi     # 0x2e588
leaq 0x16dca(%rip), %rsi     # 0x21101
callq 0x5e70
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0xa401
leaq 0x24235(%rip), %rdi     # 0x2e588
leaq 0x16e52(%rip), %rsi     # 0x211ac
callq 0x5e70
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0xa401
leaq 0x24212(%rip), %rdi     # 0x2e588
leaq 0x16d8c(%rip), %rsi     # 0x21109
callq 0x5e70
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0xa401
leaq 0x241f3(%rip), %rdi     # 0x2e588
leaq 0x16d73(%rip), %rsi     # 0x2110f
callq 0x5e70
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0xa401
leaq 0x241d4(%rip), %rdi     # 0x2e588
leaq 0x16e5d(%rip), %rsi     # 0x21218
callq 0x5e70
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0xa401
leaq 0x241b5(%rip), %rdi     # 0x2e588
leaq 0x16d3c(%rip), %rsi     # 0x21116
callq 0x5e70
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0xa401
leaq 0x24196(%rip), %rdi     # 0x2e588
leaq 0x16d23(%rip), %rsi     # 0x2111c
callq 0x5e70
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xa40a
jmp 0xa44a
callq 0xbda0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa445
cmpq $0x0, -0x8(%rbp)
jne 0xa42f
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rax, -0x8(%rbp)
jmp 0xa443
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xa445
jmp 0xa329
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JameyWoo[P]csmile/parse.cpp
// Function: var()
TreeNode* var() {
    TreeNode* t = NULL;
    TreeNode* p = NULL;
    if (ptoken.type == "Id") {
        p       = new TreeNode("Id");
        p->name = ptoken.value;
        p->line = ptoken.line;
        match("Id");
        // TODO: 添加数组
        t = p;  // 非数组时
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x23cd6(%rip), %rdi     # 0x2e588
leaq 0x168f3(%rip), %rsi     # 0x211ac
callq 0x5e70
testb $0x1, %al
jne 0xa8c7
jmp 0xaa49
movl $0xe0, %edi
callq 0x3280
movq %rax, -0xc8(%rbp)
movb $0x1, -0x45(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3480
movq -0xc0(%rbp), %rdx
leaq 0x168b2(%rip), %rsi     # 0x211ac
leaq -0x30(%rbp), %rdi
callq 0x4ef0
jmp 0xa905
movq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdb50
jmp 0xa917
movq -0xc8(%rbp), %rax
movb $0x0, -0x45(%rbp)
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x34e8
leaq -0x31(%rbp), %rdi
callq 0x32d0
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
leaq 0x23c5e(%rip), %rsi     # 0x2e5a8
callq 0x3050
movl 0x23c73(%rip), %ecx     # 0x2e5c8
movq -0x10(%rbp), %rax
movl %ecx, 0x50(%rax)
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3480
movq -0xd0(%rbp), %rdx
leaq 0x1682f(%rip), %rsi     # 0x211ac
leaq -0xb0(%rbp), %rdi
callq 0x4ef0
jmp 0xa98b
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x80b0
jmp 0xa9a0
leaq -0x90(%rbp), %rdi
callq 0x4ec0
leaq -0xb0(%rbp), %rdi
callq 0x34e8
leaq -0xb1(%rbp), %rdi
callq 0x32d0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xaa49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa9f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x34e8
leaq -0x31(%rbp), %rdi
callq 0x32d0
testb $0x1, -0x45(%rbp)
jne 0xaa02
jmp 0xaa13
movq -0xc8(%rbp), %rdi
movl $0xe0, %esi
callq 0x3290
jmp 0xaa56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xaa3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x34e8
leaq -0xb1(%rbp), %rdi
callq 0x32d0
jmp 0xaa56
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3470
nop
// File: JameyWoo[P]csmile/parse.cpp
// Function: args()
TreeNode* args() {
    TreeNode* t = new TreeNode("Args");
    TreeNode *s = NULL, *p = NULL;
    if (ptoken.type != "RightBracket") {
        s = expression();
        p = s;
        while (ptoken.type == "Comma") {
            TreeNode* q;
            match("Comma");
            q = expression();
            if (q != NULL) {
                if (s == NULL) {
                    s = p = q;
                } else {
                    p->sibling = q;
                    p          = q;
                }
            }
        }
    }
    if (s != NULL) {
        t->child[0] = s;
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0xe0, %edi
callq 0x3280
movq %rax, -0xd8(%rbp)
movb $0x1, -0x3d(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3480
movq -0xd0(%rbp), %rdx
leaq 0x16737(%rip), %rsi     # 0x211d5
leaq -0x28(%rbp), %rdi
callq 0x4ef0
jmp 0xaaa9
movq -0xd8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xdb50
jmp 0xaabb
movb $0x0, -0x3d(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x34e8
leaq -0x29(%rbp), %rdi
callq 0x32d0
movq -0xd8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
leaq 0x23a95(%rip), %rdi     # 0x2e588
leaq 0x165c2(%rip), %rsi     # 0x210bc
callq 0xdad0
testb $0x1, %al
jne 0xab08
jmp 0xac65
callq 0x9b00
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x23a68(%rip), %rdi     # 0x2e588
leaq 0x165cb(%rip), %rsi     # 0x210f2
callq 0x5e70
testb $0x1, %al
jne 0xab35
jmp 0xac63
leaq -0xc1(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x3480
movq -0xe0(%rbp), %rdx
leaq 0x1659c(%rip), %rsi     # 0x210f2
leaq -0xc0(%rbp), %rdi
callq 0x4ef0
jmp 0xab64
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x80b0
jmp 0xab79
leaq -0xa0(%rbp), %rdi
callq 0x4ec0
leaq -0xc0(%rbp), %rdi
callq 0x34e8
leaq -0xc1(%rbp), %rdi
callq 0x32d0
callq 0x9b00
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0xac5e
cmpq $0x0, -0x48(%rbp)
jne 0xac48
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rax, -0x48(%rbp)
jmp 0xac5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xabf0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x34e8
leaq -0x29(%rbp), %rdi
callq 0x32d0
testb $0x1, -0x3d(%rbp)
jne 0xac01
jmp 0xac12
movq -0xd8(%rbp), %rdi
movl $0xe0, %esi
callq 0x3290
jmp 0xac84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xac3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x34e8
leaq -0xc1(%rbp), %rdi
callq 0x32d0
jmp 0xac84
movq -0x58(%rbp), %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0xac5e
jmp 0xab19
jmp 0xac65
cmpq $0x0, -0x48(%rbp)
je 0xac77
movq -0x48(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3470
nopl (%rax)
// File: JameyWoo[P]csmile/parse.cpp
// Function: term(TreeNode*)
TreeNode* term(TreeNode* k) {
    TreeNode* t = factor(k);
    k           = NULL;
    while (ptoken.type == "MDOP") {
        TreeNode* q = new TreeNode("MDOp");
        q->op       = ptoken.value;
        q->child[0] = t;
        match(ptoken.type);
        q->child[1] = term(k);
        t           = q;
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xafb0
movq %rax, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
leaq 0x2311d(%rip), %rdi     # 0x2e588
leaq 0x15c39(%rip), %rsi     # 0x210ab
callq 0x5e70
testb $0x1, %al
jne 0xb480
jmp 0xb5dc
movl $0xe0, %edi
callq 0x3280
movq %rax, -0xc8(%rbp)
movb $0x1, -0x4d(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3480
movq -0xc0(%rbp), %rdx
leaq 0x15d3c(%rip), %rsi     # 0x211ef
leaq -0x38(%rbp), %rdi
callq 0x4ef0
jmp 0xb4be
movq -0xc8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xdb50
jmp 0xb4d0
movb $0x0, -0x4d(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34e8
leaq -0x39(%rbp), %rdi
callq 0x32d0
movq -0xc8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
leaq 0x230a5(%rip), %rsi     # 0x2e5a8
callq 0x3050
leaq 0x23079(%rip), %rsi     # 0x2e588
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
leaq -0xb8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3120
movq -0xd0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x80b0
jmp 0xb542
leaq -0x98(%rbp), %rdi
callq 0x4ec0
leaq -0xb8(%rbp), %rdi
callq 0x34e8
movq -0x8(%rbp), %rdi
callq 0xb440
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xb464
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xb59e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34e8
leaq -0x39(%rbp), %rdi
callq 0x32d0
testb $0x1, -0x4d(%rbp)
jne 0xb5af
jmp 0xb5c0
movq -0xc8(%rbp), %rdi
movl $0xe0, %esi
callq 0x3290
jmp 0xb5e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x34e8
jmp 0xb5e9
movq -0x10(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3470
nopw %cs:(%rax,%rax)
// File: JameyWoo[P]csmile/parse.cpp
// Function: additive_expression(TreeNode*)
TreeNode* additive_expression(TreeNode* k) {
    TreeNode* t = term(k);
    k           = NULL;
    while (ptoken.type == "PMOP") {  // 加减
        TreeNode* q = new TreeNode("PMOp");
        q->op       = ptoken.value;
        q->child[0] = t;
        match("PMOP");
        q->child[1] = term(k);
        t           = q;
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb440
movq %rax, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
leaq 0x22f5d(%rip), %rdi     # 0x2e588
leaq 0x15a74(%rip), %rsi     # 0x210a6
callq 0x5e70
testb $0x1, %al
jne 0xb640
jmp 0xb7d7
movl $0xe0, %edi
callq 0x3280
movq %rax, -0xd0(%rbp)
movb $0x1, -0x4d(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3480
movq -0xc8(%rbp), %rdx
leaq 0x15b81(%rip), %rsi     # 0x211f4
leaq -0x38(%rbp), %rdi
callq 0x4ef0
jmp 0xb67e
movq -0xd0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xdb50
jmp 0xb690
movb $0x0, -0x4d(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34e8
leaq -0x39(%rbp), %rdi
callq 0x32d0
movq -0xd0(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
leaq 0x22ee5(%rip), %rsi     # 0x2e5a8
callq 0x3050
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
leaq -0xb9(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x3480
movq -0xd8(%rbp), %rdx
leaq 0x159b2(%rip), %rsi     # 0x210a6
leaq -0xb8(%rbp), %rdi
callq 0x4ef0
jmp 0xb702
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x80b0
jmp 0xb717
leaq -0x98(%rbp), %rdi
callq 0x4ec0
leaq -0xb8(%rbp), %rdi
callq 0x34e8
leaq -0xb9(%rbp), %rdi
callq 0x32d0
movq -0x8(%rbp), %rdi
callq 0xb440
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xb624
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xb77f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34e8
leaq -0x39(%rbp), %rdi
callq 0x32d0
testb $0x1, -0x4d(%rbp)
jne 0xb790
jmp 0xb7a1
movq -0xd0(%rbp), %rdi
movl $0xe0, %esi
callq 0x3290
jmp 0xb7e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xb7c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x34e8
leaq -0xb9(%rbp), %rdi
callq 0x32d0
jmp 0xb7e4
movq -0x10(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3470
nopl (%rax)
// File: JameyWoo[P]csmile/parse.cpp
// Function: simple_expression(TreeNode*)
TreeNode* simple_expression(TreeNode* k) {
    // 这里会处理只有一个整数的情况
    TreeNode* t = additive_expression(k);
    k           = NULL;
    if (ptoken.type == "CompareOp") {  // 比较
        TreeNode* q = new TreeNode("CompareOp");
        q->line     = ptoken.line;
        q->op       = ptoken.value;
        q->child[0] = t;
        t           = q;
        match(ptoken.type);
        t->child[1] = additive_expression(k);
        return t;
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb600
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x22d6d(%rip), %rdi     # 0x2e588
leaq 0x1586f(%rip), %rsi     # 0x21091
callq 0x5e70
testb $0x1, %al
jne 0xb830
jmp 0xb9ac
movl $0xe0, %edi
callq 0x3280
movq %rax, -0xd0(%rbp)
movb $0x1, -0x55(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3480
movq -0xc8(%rbp), %rdx
leaq 0x1582e(%rip), %rsi     # 0x21091
leaq -0x40(%rbp), %rdi
callq 0x4ef0
jmp 0xb86e
movq -0xd0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xdb50
jmp 0xb880
movb $0x0, -0x55(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x34e8
leaq -0x41(%rbp), %rdi
callq 0x32d0
movq -0xd0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x22ce0(%rip), %rax     # 0x2e588
movq %rax, -0xe0(%rbp)
movl 0x22d13(%rip), %ecx     # 0x2e5c8
movq -0x20(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x20(%rbp), %rdi
addq $0x98, %rdi
leaq 0x22cda(%rip), %rsi     # 0x2e5a8
callq 0x3050
movq -0xe0(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0xc0(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x3120
movq -0xd8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x80b0
jmp 0xb915
leaq -0xa0(%rbp), %rdi
callq 0x4ec0
leaq -0xc0(%rbp), %rdi
callq 0x34e8
movq -0x10(%rbp), %rdi
callq 0xb600
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb9b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xb96e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x34e8
leaq -0x41(%rbp), %rdi
callq 0x32d0
testb $0x1, -0x55(%rbp)
jne 0xb97f
jmp 0xb990
movq -0xd0(%rbp), %rdi
movl $0xe0, %esi
callq 0x3290
jmp 0xb9c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x34e8
jmp 0xb9c1
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3470
nopw (%rax,%rax)
// File: JameyWoo[P]csmile/parse.cpp
// Function: expression_stmt()
TreeNode* expression_stmt() {
    TreeNode* t = NULL;
    t           = expression();
    match("Semicolon");
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq $0x0, -0x8(%rbp)
callq 0x9b00
movq %rax, -0x8(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3480
movq -0x90(%rbp), %rdx
leaq 0x153af(%rip), %rsi     # 0x210c9
leaq -0x70(%rbp), %rdi
callq 0x4ef0
jmp 0xbd25
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x80b0
jmp 0xbd34
leaq -0x50(%rbp), %rdi
callq 0x4ec0
leaq -0x70(%rbp), %rdi
callq 0x34e8
leaq -0x71(%rbp), %rdi
callq 0x32d0
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xbd85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x34e8
leaq -0x71(%rbp), %rdi
callq 0x32d0
movq -0x80(%rbp), %rdi
callq 0x3470
nopw (%rax,%rax)
// File: JameyWoo[P]csmile/parse.cpp
// Function: statement()
TreeNode* statement() {
    TreeNode* t = NULL;
    if (ptoken.type == "if") {
        t = selection_stmt();
    } else if (ptoken.type == "while") {
        t = iteration_stmt();
    } else if (ptoken.type == "return") {
        t = return_stmt();
    } else if (ptoken.type == "Id") {
        t = expression_stmt();
    } else if (ptoken.type == "intput" || ptoken.type == "output") {
        t = expression_stmt();
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
leaq 0x227d1(%rip), %rdi     # 0x2e588
leaq 0x15343(%rip), %rsi     # 0x21101
callq 0x5e70
testb $0x1, %al
jne 0xbdc9
jmp 0xbdd7
callq 0x9440
movq %rax, -0x8(%rbp)
jmp 0xbe87
leaq 0x227aa(%rip), %rdi     # 0x2e588
leaq 0x15324(%rip), %rsi     # 0x21109
callq 0x5e70
testb $0x1, %al
jne 0xbdf0
jmp 0xbdfe
callq 0xa460
movq %rax, -0x8(%rbp)
jmp 0xbe85
leaq 0x22783(%rip), %rdi     # 0x2e588
leaq 0x15303(%rip), %rsi     # 0x2110f
callq 0x5e70
testb $0x1, %al
jne 0xbe17
jmp 0xbe22
callq 0xb9d0
movq %rax, -0x8(%rbp)
jmp 0xbe83
leaq 0x2275f(%rip), %rdi     # 0x2e588
leaq 0x1537c(%rip), %rsi     # 0x211ac
callq 0x5e70
testb $0x1, %al
jne 0xbe3b
jmp 0xbe46
callq 0xbce0
movq %rax, -0x8(%rbp)
jmp 0xbe81
leaq 0x2273b(%rip), %rdi     # 0x2e588
leaq 0x153bd(%rip), %rsi     # 0x21211
callq 0x5e70
testb $0x1, %al
jne 0xbe76
leaq 0x22724(%rip), %rdi     # 0x2e588
leaq 0x152b1(%rip), %rsi     # 0x2111c
callq 0x5e70
testb $0x1, %al
jne 0xbe76
jmp 0xbe7f
callq 0xbce0
movq %rax, -0x8(%rbp)
jmp 0xbe81
jmp 0xbe83
jmp 0xbe85
jmp 0xbe87
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JameyWoo[P]csmile/parse.cpp
// Function: compound_stmt()
TreeNode* compound_stmt() {                  // * 解析函数体
    TreeNode* t = new TreeNode("Compound");  // 函数体
    match("LeftBigBkt");
    t->child[0] = local_declaration();  // 声明都在前面, 以sibling连接
    t->child[1] = statement_list();     // 下面是各种语句, 以sibling连接
    if (t->child[0] == NULL) {
        t->child[0] = t->child[1];
        t->child[1] = NULL;
    }
    t->child_cnt = 2;
    match("RightBigBkt");
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl $0xe0, %edi
callq 0x3280
movq %rax, -0x130(%rbp)
movb $0x1, -0x3d(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x3480
movq -0x128(%rbp), %rdx
leaq 0x15344(%rip), %rsi     # 0x21222
leaq -0x28(%rbp), %rdi
callq 0x4ef0
jmp 0xbee9
movq -0x130(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xdb50
jmp 0xbefb
movb $0x0, -0x3d(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x34e8
leaq -0x29(%rbp), %rdi
callq 0x32d0
movq -0x130(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x3480
movq -0x138(%rbp), %rdx
leaq 0x1519e(%rip), %rsi     # 0x210db
leaq -0xa8(%rbp), %rdi
callq 0x4ef0
jmp 0xbf4b
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x80b0
jmp 0xbf60
leaq -0x88(%rbp), %rdi
callq 0x4ec0
leaq -0xa8(%rbp), %rdi
callq 0x34e8
leaq -0xa9(%rbp), %rdi
callq 0x32d0
callq 0x8bf0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
callq 0xa310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xc052
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0xc052
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xbff4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x34e8
leaq -0x29(%rbp), %rdi
callq 0x32d0
testb $0x1, -0x3d(%rbp)
jne 0xc005
jmp 0xc016
movq -0x130(%rbp), %rdi
movl $0xe0, %esi
callq 0x3290
jmp 0xc104
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xc041
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x34e8
leaq -0xa9(%rbp), %rdi
callq 0x32d0
jmp 0xc104
movq -0x8(%rbp), %rax
movl $0x2, 0x28(%rax)
leaq -0x119(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x3480
movq -0x140(%rbp), %rdx
leaq 0x15068(%rip), %rsi     # 0x210e6
leaq -0x118(%rbp), %rdi
callq 0x4ef0
jmp 0xc08c
leaq -0xf8(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x80b0
jmp 0xc0a1
leaq -0xf8(%rbp), %rdi
callq 0x4ec0
leaq -0x118(%rbp), %rdi
callq 0x34e8
leaq -0x119(%rbp), %rdi
callq 0x32d0
movq -0x8(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xc0f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x34e8
leaq -0x119(%rbp), %rdi
callq 0x32d0
movq -0x38(%rbp), %rdi
callq 0x3470
nopl (%rax)
// File: JameyWoo[P]csmile/parse.cpp
// Function: declaration_list()
TreeNode* declaration_list() {
    /**
     * 不断检测声明
     * 包括函数声明和变量声明.
     */
    TreeNode* t = declaration();  // 检测一个声明
    TreeNode* p = t;
    // while (ptoken.type != "int" && ptoken.type != "void" && ptoken.type != "EndFile") {
    //     ptoken = getToken();
    //     if (ptoken.type == "EndFile") break;
    // }
    while (ptoken.type == "int" || ptoken.type == "void") {  // 检测到int整形, void函数
        // cout << "声明的类型 ................... : " << ptoken.type << endl;
        TreeNode* q;
        q = declaration();
        if (q != NULL) {
            if (t == NULL) {  // ! 似乎不正常, 前面t为NULL说明没有检测到decl, 可以报错
                t = p = q;
            } else {
                p->sibling = q;  // *每个声明是并列的, 用兄弟结点连接.
                p          = q;
            }
        }
    }
    match("EndFile");
    // cout << "hehe\n";
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
callq 0xc110
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x217d5(%rip), %rdi     # 0x2e588
leaq 0x1433e(%rip), %rsi     # 0x210f8
callq 0x5e70
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x95(%rbp)
jne 0xcde7
leaq 0x217b3(%rip), %rdi     # 0x2e588
leaq 0x14320(%rip), %rsi     # 0x210fc
callq 0x5e70
movb %al, -0x95(%rbp)
movb -0x95(%rbp), %al
testb $0x1, %al
jne 0xcdf3
jmp 0xce33
callq 0xc110
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xce2e
cmpq $0x0, -0x8(%rbp)
jne 0xce18
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rax, -0x8(%rbp)
jmp 0xce2c
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xce2e
jmp 0xcdac
leaq -0x81(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3480
movq -0xa0(%rbp), %rdx
leaq 0x14231(%rip), %rsi     # 0x21085
leaq -0x80(%rbp), %rdi
callq 0x4ef0
jmp 0xce5f
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x80b0
jmp 0xce6e
leaq -0x60(%rbp), %rdi
callq 0x4ec0
leaq -0x80(%rbp), %rdi
callq 0x34e8
leaq -0x81(%rbp), %rdi
callq 0x32d0
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0xcec8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x34e8
leaq -0x81(%rbp), %rdi
callq 0x32d0
movq -0x90(%rbp), %rdi
callq 0x3470
// File: JameyWoo[P]csmile/parse.cpp
// Function: printParse(TreeNode*)
void printParse(TreeNode* t) {
    out << "Program:{\n"
        << "  type: program,\n"
        << "  body: [\n";
    string indent = "    ";
    preOrder(t, indent);
    out << "  ]\n"
        << "}\n";
    out.close();
    // ifstream in("parse.txt", ios::in);
    // 输出到控制台
    // string s;
    // while (getline(in, s)) {
    //     cout << s << endl;
    // }
    cout << "error cnt: " << error_cnt << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x20cea(%rip), %rdi     # 0x2e5d0
leaq 0x139fe(%rip), %rsi     # 0x212eb
callq 0x3270
movq %rax, %rdi
leaq 0x139fa(%rip), %rsi     # 0x212f6
callq 0x3270
movq %rax, %rdi
leaq 0x139b6(%rip), %rsi     # 0x212c1
callq 0x3270
leaq -0x29(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3480
movq -0x68(%rbp), %rdx
leaq 0x139a6(%rip), %rsi     # 0x212ce
leaq -0x28(%rbp), %rdi
callq 0x4ef0
jmp 0xd933
leaq -0x29(%rbp), %rdi
callq 0x32d0
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3120
jmp 0xd953
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xcee0
jmp 0xd962
leaq -0x60(%rbp), %rdi
callq 0x34e8
leaq 0x20c5e(%rip), %rdi     # 0x2e5d0
leaq 0x1395c(%rip), %rsi     # 0x212d5
callq 0x3270
movq %rax, -0x78(%rbp)
jmp 0xd984
movq -0x78(%rbp), %rdi
leaq 0x1394d(%rip), %rsi     # 0x212dc
callq 0x3270
jmp 0xd996
leaq 0x20c33(%rip), %rdi     # 0x2e5d0
callq 0x33c0
jmp 0xd9a4
movq 0x2061d(%rip), %rdi     # 0x2dfc8
leaq 0x13956(%rip), %rsi     # 0x21308
callq 0x3270
movq %rax, -0x80(%rbp)
jmp 0xd9bd
movq -0x80(%rbp), %rdi
movl 0x20e09(%rip), %esi     # 0x2e7d0
callq 0x3460
movq %rax, -0x88(%rbp)
jmp 0xd9d5
movq -0x88(%rbp), %rdi
movq 0x205cd(%rip), %rsi     # 0x2dfb0
callq 0x32b0
jmp 0xd9ea
leaq -0x28(%rbp), %rdi
callq 0x34e8
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x32d0
jmp 0xda3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xda36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x34e8
leaq -0x28(%rbp), %rdi
callq 0x34e8
movq -0x38(%rbp), %rdi
callq 0x3470
nopl (%rax,%rax)
// File: JameyWoo[P]csmile/parse.cpp
// Function: parse(bool)
TreeNode* parse(bool print) {
    TreeNode* t;
    ptoken = getToken();          // 获取第一个token, 开始语法分析
    t      = declaration_list();  // 获取声明列表, c-由一系列整数/函数声明组成
    if (print) {
        printParse(t);
        cout << "parse print over !" << endl;
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5460
leaq 0x20b18(%rip), %rdi     # 0x2e588
leaq -0x58(%rbp), %rsi
callq 0xdb00
leaq -0x58(%rbp), %rdi
callq 0x4ec0
callq 0xcd90
movq %rax, -0x10(%rbp)
testb $0x1, -0x1(%rbp)
je 0xdabc
movq -0x10(%rbp), %rdi
callq 0xd8d0
movq 0x20527(%rip), %rdi     # 0x2dfc8
leaq 0x1386c(%rip), %rsi     # 0x21314
callq 0x3270
movq %rax, %rdi
movq 0x204f9(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JameyWoo[P]csmile/analyze.cpp
// Function: buildSymtab(TreeNode*)
void buildSymtab(TreeNode *syntaxTree) {
    traverse(syntaxTree, insertNode, nullProc);
    if (not isError) {
        cout << "\nprinting symtab ..." << endl;
        printSymtab();
        cout << "print over !\n"
                  << endl;
        cout << "symtab build over, everything is ok! congratulations!" << endl
                  << endl;
    } else {
        cout << "you have " << isError << " errors in symtab, please check!" << endl
                  << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x169(%rip), %rsi       # 0xdfd0
leaq 0x7e2(%rip), %rdx       # 0xe650
callq 0xdf50
cmpl $0x0, 0x20b66(%rip)     # 0x2e9e0
jne 0xdef8
movq 0x20145(%rip), %rdi     # 0x2dfc8
leaq 0x134b4(%rip), %rsi     # 0x2133e
callq 0x3270
movq %rax, %rdi
movq 0x20117(%rip), %rsi     # 0x2dfb0
callq 0x32b0
callq 0x10bb0
movq 0x2011e(%rip), %rdi     # 0x2dfc8
leaq 0x134a2(%rip), %rsi     # 0x21353
callq 0x3270
movq %rax, %rdi
movq 0x200f0(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq 0x200fc(%rip), %rdi     # 0x2dfc8
leaq 0x1348e(%rip), %rsi     # 0x21361
callq 0x3270
movq %rax, %rdi
movq 0x200ce(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq %rax, %rdi
movq 0x200bf(%rip), %rsi     # 0x2dfb0
callq 0x32b0
jmp 0xdf46
movq 0x200c9(%rip), %rdi     # 0x2dfc8
leaq 0x13491(%rip), %rsi     # 0x21397
callq 0x3270
movq %rax, %rdi
movl 0x20acc(%rip), %esi     # 0x2e9e0
callq 0x3460
movq %rax, %rdi
leaq 0x1347e(%rip), %rsi     # 0x213a1
callq 0x3270
movq %rax, %rdi
movq 0x2007e(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq %rax, %rdi
movq 0x2006f(%rip), %rsi     # 0x2dfb0
callq 0x32b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: JameyWoo[P]csmile/analyze.cpp
// Function: traverse(TreeNode*, void (*)(TreeNode*), void (*)(TreeNode*))
static void traverse(TreeNode *t, void (*preProc)(TreeNode *), void (*postProc)(TreeNode *)) {
    if (t != NULL) {
        preProc(t);
        for (int i = 0; i < MAX_CHILDREN; ++i) {
            traverse(t->child[i], preProc, postProc);
        }
        postProc(t);
        traverse(t->sibling, preProc, postProc);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xdfc5
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0xdfa6
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xdf50
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xdf7c
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xdf50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: JameyWoo[P]csmile/analyze.cpp
// Function: nullProc(TreeNode*)
static void nullProc(TreeNode *t) {
    if (t == NULL)
        return;
    else
        return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xe661
jmp 0xe663
jmp 0xe663
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JameyWoo[P]csmile/analyze.cpp
// Function: typeCheck(TreeNode*)
void typeCheck(TreeNode *syntaxTree) {
    traverse(syntaxTree, nullProc, checkNode);
    if (typeError) {
        cout << "type check over, your have " << typeError << " errors, please check!" << endl
             << endl;
    } else {
        cout << "type check over, everything is ok! congratulations!" << endl
             << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x37(%rip), %rsi       # 0xe650
leaq 0xa2(%rip), %rdx        # 0xe730
callq 0xdf50
cmpl $0x0, 0x2034a(%rip)     # 0x2e9e4
je 0xe6ec
movq 0x1f925(%rip), %rdi     # 0x2dfc8
leaq 0x12d18(%rip), %rsi     # 0x213c2
callq 0x3270
movq %rax, %rdi
movl 0x2032c(%rip), %esi     # 0x2e9e4
callq 0x3460
movq %rax, %rdi
leaq 0x12d17(%rip), %rsi     # 0x213de
callq 0x3270
movq %rax, %rdi
movq 0x1f8da(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq %rax, %rdi
movq 0x1f8cb(%rip), %rsi     # 0x2dfb0
callq 0x32b0
jmp 0xe71d
movq 0x1f8d5(%rip), %rdi     # 0x2dfc8
leaq 0x12cfb(%rip), %rsi     # 0x213f5
callq 0x3270
movq %rax, %rdi
movq 0x1f8a7(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq %rax, %rdi
movq 0x1f898(%rip), %rsi     # 0x2dfb0
callq 0x32b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JameyWoo[P]csmile/symtab.cpp
// Function: newSymtabs()
void newSymtabs() {
    // 只有当符号表不为空地时候建立
    if (symtabs.size() != 0) {
        vec_symtabs.push_back(symtabs);
    }
    symtabs.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1e19d(%rip), %rdi     # 0x2ea58
callq 0x11100
cmpq $0x0, %rax
je 0x108d9
leaq 0x1e173(%rip), %rdi     # 0x2ea40
leaq 0x1e184(%rip), %rsi     # 0x2ea58
callq 0x11120
leaq 0x1e178(%rip), %rdi     # 0x2ea58
callq 0x11190
popq %rbp
retq
nopw (%rax,%rax)
// File: JameyWoo[P]csmile/symtab.cpp
// Function: st_lookup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int st_lookup(string name) {
    if (symtabs.count(name) == 0) {
        return -1;
    } else {
        return symtabs[name].addr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1e14e(%rip), %rdi     # 0x2ea58
callq 0x111b0
cmpq $0x0, %rax
jne 0x1091e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10934
movq -0x18(%rbp), %rsi
leaq 0x1e12f(%rip), %rdi     # 0x2ea58
callq 0x11210
movl 0x20(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: JameyWoo[P]csmile/assembly.cpp
// Function: genInput(TreeNode*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void genInput(TreeNode* input, string left_loc) {
    // debug(input->nodekind);
    assout << "\tmovl\t$.LC1, %eax" << endl
           << "\tleal\t" << left_loc << ", %edx" << endl
           << "\tmovl\t"
           << "%edx, 4(%esp)" << endl
           << "\tmovl\t%eax, (%esp)" << endl
           << "\tcall\t__isoc99_scanf" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1642d(%rip), %rdi     # 0x2eca8
leaq 0x8e61(%rip), %rsi      # 0x216e3
callq 0x3270
movq %rax, %rdi
movq 0x1571f(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq %rax, %rdi
leaq 0x8e55(%rip), %rsi      # 0x216f5
callq 0x3270
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
leaq 0x8f1d(%rip), %rsi      # 0x217d8
callq 0x3270
movq %rax, %rdi
movq 0x156e6(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq %rax, %rdi
leaq 0x8dbd(%rip), %rsi      # 0x21696
callq 0x3270
movq %rax, %rdi
leaq 0x8e14(%rip), %rsi      # 0x216fc
callq 0x3270
movq %rax, %rdi
movq 0x156b9(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq %rax, %rdi
leaq 0x8dbd(%rip), %rsi      # 0x216c3
callq 0x3270
movq %rax, %rdi
movq 0x1569b(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq %rax, %rdi
leaq 0x8de6(%rip), %rsi      # 0x2170a
callq 0x3270
movq %rax, %rdi
movq 0x1567d(%rip), %rsi     # 0x2dfb0
callq 0x32b0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: JameyWoo[P]csmile/assembly.cpp
// Function: solveCompare(TreeNode*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>)
void solveCompare(TreeNode* root, string reg, map<string, string> var2stack) {
    // debug(root->nodekind);
    // TODO: 最好有一个通用处理的函数, 专门计算 exp等
    if (root->nodekind == "Const") {
        assout << "\tmovl\t$" << to_string(root->val) << ", " << reg << endl;
    } else if (root->nodekind == "Id") {
        assout << "\tmovl\t" << var2stack[root->name] << ", " << reg << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
leaq 0x6a9b(%rip), %rsi      # 0x211e9
callq 0x5e70
testb $0x1, %al
jne 0x1a75c
jmp 0x1a800
leaq 0x14545(%rip), %rdi     # 0x2eca8
leaq 0x6fb5(%rip), %rsi      # 0x2171f
callq 0x3270
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rax
movl 0xb8(%rax), %esi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xf460
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x3240
movq %rax, -0x60(%rbp)
jmp 0x1a79d
movq -0x60(%rbp), %rdi
leaq 0x6fef(%rip), %rsi      # 0x21797
callq 0x3270
movq %rax, -0x78(%rbp)
jmp 0x1a7b3
movq -0x58(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x3240
movq %rax, -0x80(%rbp)
jmp 0x1a7c6
movq -0x80(%rbp), %rdi
movq 0x137df(%rip), %rsi     # 0x2dfb0
callq 0x32b0
jmp 0x1a7d8
leaq -0x38(%rbp), %rdi
callq 0x34e8
jmp 0x1a883
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34e8
jmp 0x1a88c
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
leaq 0x699d(%rip), %rsi      # 0x211ac
callq 0x5e70
testb $0x1, %al
jne 0x1a81a
jmp 0x1a881
leaq 0x14487(%rip), %rdi     # 0x2eca8
leaq 0x6e6e(%rip), %rsi      # 0x21696
callq 0x3270
movq -0x50(%rbp), %rdi
movq %rax, -0x88(%rbp)
movq -0x8(%rbp), %rsi
addq $0xc0, %rsi
callq 0xf2e0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x3240
movq %rax, %rdi
leaq 0x6f36(%rip), %rsi      # 0x21797
callq 0x3270
movq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
movq 0x13734(%rip), %rsi     # 0x2dfb0
callq 0x32b0
jmp 0x1a883
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3470
nopw %cs:(%rax,%rax)
// File: JameyWoo[P]csmile/assembly.cpp
// Function: genAssembly(TreeNode*)
void genAssembly(TreeNode* root) {
    // 汇编代码的头部
    assout << "\t.section\t.rodata" << endl
           << ".LC0:" << endl
           << "\t"
           << ".string \"%d\\n\"" << endl
           << ".LC1:" << endl
           << "\t"
           << ".string \"%d\"" << endl
           << "\t"
           << ".text" << endl;

    // 函数部分, 遍历每个 function, 单独处理
    TreeNode* func = root;
    while (func != NULL) {
        genFunc(func);
        func = func->sibling;
        LFB_id++;
        LFE_id++;
    }

    assout << "\t.ident	\"GCC: (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3\"" << endl
           << "\t.section"
           << "\t"
           << ".note.GNU-stack,\"\",@progbits " << endl;

    cout << "the end..." << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x13085(%rip), %rdi     # 0x2eca8
leaq 0x5c58(%rip), %rsi      # 0x21882
callq 0x3270
movq %rax, %rdi
movq 0x12377(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq %rax, %rdi
leaq 0x5c4c(%rip), %rsi      # 0x21894
callq 0x3270
movq %rax, %rdi
movq 0x12359(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq %rax, %rdi
leaq 0x5a2e(%rip), %rsi      # 0x21694
callq 0x3270
movq %rax, %rdi
leaq 0x5c25(%rip), %rsi      # 0x2189a
callq 0x3270
movq %rax, %rdi
movq 0x1232c(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq %rax, %rdi
leaq 0x5c16(%rip), %rsi      # 0x218a9
callq 0x3270
movq %rax, %rdi
movq 0x1230e(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq %rax, %rdi
leaq 0x59e3(%rip), %rsi      # 0x21694
callq 0x3270
movq %rax, %rdi
leaq 0x5bef(%rip), %rsi      # 0x218af
callq 0x3270
movq %rax, %rdi
movq 0x122e1(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq %rax, %rdi
leaq 0x59b6(%rip), %rsi      # 0x21694
callq 0x3270
movq %rax, %rdi
leaq 0x5bcf(%rip), %rsi      # 0x218bc
callq 0x3270
movq %rax, %rdi
movq 0x122b4(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1bd45
movq -0x10(%rbp), %rdi
callq 0x1b1e0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movl 0x131dd(%rip), %eax     # 0x2ef08
addl $0x1, %eax
movl %eax, 0x131d4(%rip)     # 0x2ef08
movl 0x131d2(%rip), %eax     # 0x2ef0c
addl $0x1, %eax
movl %eax, 0x131c9(%rip)     # 0x2ef0c
jmp 0x1bd09
leaq 0x12f5c(%rip), %rdi     # 0x2eca8
leaq 0x5b6f(%rip), %rsi      # 0x218c2
callq 0x3270
movq %rax, %rdi
movq 0x1224e(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq %rax, %rdi
leaq 0x5b85(%rip), %rsi      # 0x218f6
callq 0x3270
movq %rax, %rdi
leaq 0x5914(%rip), %rsi      # 0x21694
callq 0x3270
movq %rax, %rdi
leaq 0x5b71(%rip), %rsi      # 0x21900
callq 0x3270
movq %rax, %rdi
movq 0x12212(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq 0x1221e(%rip), %rdi     # 0x2dfc8
leaq 0x5b6d(%rip), %rsi      # 0x2191e
callq 0x3270
movq %rax, %rdi
movq 0x121f0(%rip), %rsi     # 0x2dfb0
callq 0x32b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::getNodeByKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
JsonPtr Json::getNodeByKey(const std::string& key)
{
	if (_type != JSON_Object)
		return nullptr;

	std::map<std::string, JsonPtr>* data = (std::map<std::string, JsonPtr>*)_data;
	auto it = data->find(key);
	if (it != data->end())
		return it->second;
	else
		return nullptr;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, (%rax)
je 0x36e0d
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3ec30
jmp 0x36e7c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x3ec50
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3ea30
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3ea60
testb $0x1, %al
jne 0x36e53
jmp 0x36e6f
leaq 0x20(%rsp), %rdi
callq 0x3ec80
movq (%rsp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x31120
jmp 0x36e7c
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3ec30
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::getNodeByIndex(int)
JsonPtr Json::getNodeByIndex(int index)
{
	if (_type != JSON_Array)
		return nullptr;

	std::list<JsonPtr>* data = (std::list<JsonPtr>*)_data;
	auto it = data->begin();
	int i = 0;
	for (; it != data->end(); it++, i++)
	{
		if (i == index)
			return *it;
	}

	return nullptr;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x1, (%rax)
je 0x36ecf
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3ec30
jmp 0x36f67
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3ead0
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3eb00
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3eb30
testb $0x1, %al
jne 0x36f18
jmp 0x36f5a
movl 0x2c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jne 0x36f3a
leaq 0x30(%rsp), %rdi
callq 0x3eb50
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x31120
jmp 0x36f67
jmp 0x36f3c
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x3eca0
movq %rax, 0x18(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x36ef4
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3ec30
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::getNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
JsonPtr Json::getNode(const std::string& path, const std::string& delim)
{
	std::vector<std::string> sections;
	pathSplit(path, delim, sections);

	if (sections.empty())
		return getNodeByKey("");

	JsonPtr node = getNodeByKey(sections[0]);
	for (size_t i = 1; i < sections.size() && node != nullptr; i++)
		node = node->getNodeByKey(sections[i]);

	return node;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x3ecd0
movq 0x40(%rsp), %rdx
movq 0xc0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0x36a80
jmp 0x36fef
leaq 0xa0(%rsp), %rdi
callq 0x3ece0
testb $0x1, %al
jne 0x37005
jmp 0x370bf
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x224b0
movq 0x20(%rsp), %rdx
leaq 0x14454(%rip), %rsi     # 0x4b474
leaq 0x70(%rsp), %rdi
callq 0x30e50
jmp 0x3702c
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0x36dd0
jmp 0x37042
leaq 0x70(%rsp), %rdi
callq 0x22160
leaq 0x6f(%rsp), %rdi
callq 0x22320
movl $0x1, 0x68(%rsp)
jmp 0x371dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x371f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x370b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x22160
leaq 0x6f(%rsp), %rdi
callq 0x22320
jmp 0x371f6
movb $0x0, 0x67(%rsp)
xorl %eax, %eax
movl %eax, %esi
leaq 0xa0(%rsp), %rdi
callq 0x3ed30
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %rax, %rdx
callq 0x36dd0
jmp 0x370e9
movq $0x1, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x3ed50
movq 0x10(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x1f(%rsp)
jae 0x3712e
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x33d70
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x3713b
jmp 0x371bc
movq 0x28(%rsp), %rdi
callq 0x312a0
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x3ed30
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x48(%rsp), %rdi
callq 0x36dd0
jmp 0x37170
movq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x31350
leaq 0x48(%rsp), %rdi
callq 0x31150
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x370f2
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x31150
jmp 0x371f6
movb $0x1, 0x67(%rsp)
movl $0x1, 0x68(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x371da
movq 0x28(%rsp), %rdi
callq 0x31150
jmp 0x371dc
leaq 0xa0(%rsp), %rdi
callq 0x32770
movq 0x30(%rsp), %rax
addq $0xd8, %rsp
retq
leaq 0xa0(%rsp), %rdi
callq 0x32770
movq 0x98(%rsp), %rdi
callq 0x224a0
// File: swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::setDict()
void Json::setDict()
{
	if (_type != JSON_Object)
	{
		clean();
		_type = JSON_Object;
		_data = new std::map<std::string, JsonPtr>();
	}
	else
	{
		std::map<std::string, JsonPtr>* data = (std::map<std::string, JsonPtr>*)_data;
		data->clear();
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, (%rax)
je 0x37e75
movq 0x10(%rsp), %rdi
callq 0x380b0
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movl $0x30, %edi
callq 0x222b0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x22130
movq 0x8(%rsp), %rdi
callq 0x3eed0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x37e8d
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x3eee0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)