LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: declaration(int)
void declaration(int k)
{
	TreeNode tNode= tree.node[k];
    if (lookahead(k) == 2)//2是identifier_list
    {
        int idType = type(tree.node[k].child[2]);//获取此声明的类型
        code[currentLine].append(" " );
        identifier_list(idType, tree.node[k].child[0], 1);
        code[currentLine++].append(";\n");
        declaration1(tree.node[k].child[4]);
    }
    else
        cout<<"declaration error!"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb7758(%rip), %rax     # 0xc6138
leaq 0x8(%rax,%rcx), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x14920
movl -0x4(%rbp), %edi
callq 0xca50
movl %eax, -0xc4(%rbp)
jmp 0xea01
movl -0xc4(%rbp), %eax
cmpl $0x2, %eax
jne 0xeaf6
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb7716(%rip), %rax     # 0xc6138
movl 0x14(%rax,%rcx), %edi
callq 0xeb50
movl %eax, -0xc8(%rbp)
jmp 0xea33
movl -0xc8(%rbp), %eax
movl %eax, -0xc0(%rbp)
movslq 0xb1bda(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xb0f4f(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xfaa0(%rip), %rsi      # 0x1e4fb
callq 0x3490
jmp 0xea62
movl -0xc0(%rbp), %edi
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb76be(%rip), %rax     # 0xc6138
movl 0xc(%rax,%rcx), %esi
movl $0x1, %edx
callq 0xcd10
jmp 0xea8a
movslq 0xb1b8f(%rip), %rax     # 0xc0620
movl %eax, %ecx
incl %ecx
movl %ecx, 0xb1b85(%rip)     # 0xc0620
shlq $0x5, %rax
leaq 0xb0efa(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xff5e(%rip), %rsi      # 0x1ea0e
callq 0x3490
jmp 0xeab7
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb766f(%rip), %rax     # 0xc6138
movl 0x1c(%rax,%rcx), %edi
callq 0xf090
jmp 0xead4
jmp 0xeb29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x14a90
jmp 0xeb3e
movq 0x174cb(%rip), %rdi     # 0x25fc8
leaq 0xfb7c(%rip), %rsi      # 0x1e680
callq 0x3280
movq %rax, -0xd0(%rbp)
jmp 0xeb12
movq -0xd0(%rbp), %rdi
movq 0x17490(%rip), %rsi     # 0x25fb0
callq 0x32b0
jmp 0xeb27
jmp 0xeb29
leaq -0xb0(%rbp), %rdi
callq 0x14a90
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: declaration1(int)
void declaration1(int k)
{
    if (lookahead(k) == 2)//2是identifier_list
    {
        int idType = type(tree.node[k].child[2]);//获取此声明的类型
        code[currentLine].append(" " );
        identifier_list(idType, tree.node[k].child[0], 1);
        code[currentLine++].append(";\n");
        declaration1(tree.node[k].child[4]);
    }
    else if (lookahead(k) == 106)//e
    {}
    else
        cout<<"declaration' error!"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0xca50
cmpl $0x2, %eax
jne 0xf16a
movslq -0x4(%rbp), %rcx
leaq 0xb7081(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %edi
callq 0xeb50
movl %eax, -0x8(%rbp)
movslq 0xb1549(%rip), %rax     # 0xc0620
leaq 0xb08c2(%rip), %rdi     # 0xbf9a0
shlq $0x5, %rax
addq %rax, %rdi
leaq 0xf40f(%rip), %rsi      # 0x1e4fb
callq 0x3490
movl -0x8(%rbp), %edi
movslq -0x4(%rbp), %rcx
leaq 0xb7039(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %esi
movl $0x1, %edx
callq 0xcd10
movl 0xb1500(%rip), %eax     # 0xc0620
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xb14f5(%rip)     # 0xc0620
cltq
leaq 0xb086c(%rip), %rdi     # 0xbf9a0
shlq $0x5, %rax
addq %rax, %rdi
leaq 0xf8cc(%rip), %rsi      # 0x1ea0e
callq 0x3490
movslq -0x4(%rbp), %rcx
leaq 0xb6fe6(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %edi
callq 0xf090
jmp 0xf19d
movl -0x4(%rbp), %edi
callq 0xca50
cmpl $0x6a, %eax
jne 0xf179
jmp 0xf19b
movq 0x16e48(%rip), %rdi     # 0x25fc8
leaq 0xf45b(%rip), %rsi      # 0x1e5e2
callq 0x3280
movq %rax, %rdi
movq 0x16e1a(%rip), %rsi     # 0x25fb0
callq 0x32b0
jmp 0xf19d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: standard_type(int)
int standard_type(int k)
{
	TreeNode tNode= tree.node[k];
	TreeNode childNode;
    if (lookahead(k) == 116)//int
    {
    	code[currentLine].append("int");
        return 1;
    }
    else if(lookahead(k) == 117)//real
    {
    	code[currentLine].append("float");
        return 2;
    }
    else if(lookahead(k) == 118)//bool
    {
    	code[currentLine].append("boolean");
        return 3;
    }
    else if(lookahead(k) == 119)//num
    {
        return -1;
    }
    else
    {
        cout<<"standard_type error!"<<endl;
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movl %edi, -0x8(%rbp)
movslq -0x8(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb6f68(%rip), %rax     # 0xc6138
leaq 0x8(%rax,%rcx), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x14920
leaq -0x158(%rbp), %rdi
callq 0x149d0
movl -0x8(%rbp), %edi
callq 0xca50
movl %eax, -0x16c(%rbp)
jmp 0xf1fd
movl -0x16c(%rbp), %eax
cmpl $0x74, %eax
jne 0xf270
movslq 0xb1411(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xb0786(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xf3f3(%rip), %rsi      # 0x1e617
callq 0x3490
jmp 0xf22b
movl $0x1, -0x4(%rbp)
movl $0x1, -0x168(%rbp)
jmp 0xf385
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
jmp 0xf3a9
movl -0x8(%rbp), %edi
callq 0xca50
movl %eax, -0x170(%rbp)
jmp 0xf280
movl -0x170(%rbp), %eax
cmpl $0x75, %eax
jne 0xf2c4
movslq 0xb138e(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xb0703(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xf374(%rip), %rsi      # 0x1e61b
callq 0x3490
jmp 0xf2ae
movl $0x2, -0x4(%rbp)
movl $0x1, -0x168(%rbp)
jmp 0xf385
movl -0x8(%rbp), %edi
callq 0xca50
movl %eax, -0x174(%rbp)
jmp 0xf2d4
movl -0x174(%rbp), %eax
cmpl $0x76, %eax
jne 0xf315
movslq 0xb133a(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xb06af(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xed19(%rip), %rsi      # 0x1e014
callq 0x3490
jmp 0xf302
movl $0x3, -0x4(%rbp)
movl $0x1, -0x168(%rbp)
jmp 0xf385
movl -0x8(%rbp), %edi
callq 0xca50
movl %eax, -0x178(%rbp)
jmp 0xf325
movl -0x178(%rbp), %eax
cmpl $0x77, %eax
jne 0xf343
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x168(%rbp)
jmp 0xf385
movq 0x16c7e(%rip), %rdi     # 0x25fc8
leaq 0xf2d0(%rip), %rsi      # 0x1e621
callq 0x3280
movq %rax, -0x180(%rbp)
jmp 0xf35f
movq -0x180(%rbp), %rdi
movq 0x16c43(%rip), %rsi     # 0x25fb0
callq 0x32b0
jmp 0xf374
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x168(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
movl -0x4(%rbp), %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0x160(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: subprogram_declarations1(int)
void subprogram_declarations1(int k)
{
	TreeNode tNode= tree.node[k];
	TreeNode childNode;
    if (lookahead(k) == 12)//12是subprogram_declaration
    {
        subprogram_declaration(tree.node[k].child[0]);
        currentLine++;
        subprogram_declarations1(tree.node[k].child[2]);
    }
    else if (lookahead(k) == 106)//e
    {}
    else
        cout<<"subprogram_declarations' error!"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb6d58(%rip), %rax     # 0xc6138
leaq 0x8(%rax,%rcx), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x14920
leaq -0x158(%rbp), %rdi
callq 0x149d0
movl -0x4(%rbp), %edi
callq 0xca50
movl %eax, -0x168(%rbp)
jmp 0xf40d
movl -0x168(%rbp), %eax
cmpl $0xc, %eax
jne 0xf48e
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb6d0e(%rip), %rax     # 0xc6138
movl 0xc(%rax,%rcx), %edi
callq 0xf510
jmp 0xf435
movl 0xb11e5(%rip), %eax     # 0xc0620
incl %eax
movl %eax, 0xb11dd(%rip)     # 0xc0620
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb6ce3(%rip), %rax     # 0xc6138
movl 0x14(%rax,%rcx), %edi
callq 0xf3c0
jmp 0xf460
jmp 0xf4e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
jmp 0xf501
movl -0x4(%rbp), %edi
callq 0xca50
movl %eax, -0x16c(%rbp)
jmp 0xf49e
movl -0x16c(%rbp), %eax
cmpl $0x6a, %eax
jne 0xf4ab
jmp 0xf4de
movq 0x16b16(%rip), %rdi     # 0x25fc8
leaq 0xf19c(%rip), %rsi      # 0x1e655
callq 0x3280
movq %rax, -0x178(%rbp)
jmp 0xf4c7
movq -0x178(%rbp), %rdi
movq 0x16adb(%rip), %rsi     # 0x25fb0
callq 0x32b0
jmp 0xf4dc
jmp 0xf4de
jmp 0xf4e0
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0x160(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: subprogram_declaration(int)
void subprogram_declaration(int k)
{
	TreeNode tNode= tree.node[k];
    if (lookahead(k) == 13)//13是subprogram_head
    {
        subprogram_head(tree.node[k].child[0]);
        code[currentLine++].append("{\n");
        declarations(tree.node[k].child[1]);
        
        compound_statement(tree.node[k].child[2]);
        code[currentLine++].append("}\n");
        
        if (currentTable != "main") {
            currentTable = "main";
        }
    }
    else
        cout<<"subprogram_declaration error!"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb6c08(%rip), %rax     # 0xc6138
leaq 0x8(%rax,%rcx), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x14920
movl -0x4(%rbp), %edi
callq 0xca50
movl %eax, -0xc0(%rbp)
jmp 0xf551
movl -0xc0(%rbp), %eax
cmpl $0xd, %eax
jne 0xf671
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb6bc6(%rip), %rax     # 0xc6138
movl 0xc(%rax,%rcx), %edi
callq 0xf6d0
jmp 0xf57d
movslq 0xb109c(%rip), %rax     # 0xc0620
movl %eax, %ecx
incl %ecx
movl %ecx, 0xb1092(%rip)     # 0xc0620
shlq $0x5, %rax
leaq 0xb0407(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xf06f(%rip), %rsi      # 0x1e612
callq 0x3490
jmp 0xf5aa
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb6b7c(%rip), %rax     # 0xc6138
movl 0x10(%rax,%rcx), %edi
callq 0xe6d0
jmp 0xf5c7
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb6b5f(%rip), %rax     # 0xc6138
movl 0x14(%rax,%rcx), %edi
callq 0xe870
jmp 0xf5e4
movslq 0xb1035(%rip), %rax     # 0xc0620
movl %eax, %ecx
incl %ecx
movl %ecx, 0xb102b(%rip)     # 0xc0620
shlq $0x5, %rax
leaq 0xb03a0(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xefc1(%rip), %rsi      # 0x1e5cb
callq 0x3490
jmp 0xf611
leaq 0xb0360(%rip), %rdi     # 0xbf978
leaq 0xee9b(%rip), %rsi      # 0x1e4ba
callq 0x14ad0
movb %al, -0xc1(%rbp)
jmp 0xf62c
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0xf638
jmp 0xf66f
leaq 0xb0339(%rip), %rdi     # 0xbf978
leaq 0xee74(%rip), %rsi      # 0x1e4ba
callq 0x3380
jmp 0xf64d
jmp 0xf66f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x14a90
jmp 0xf6b9
jmp 0xf6a4
movq 0x16950(%rip), %rdi     # 0x25fc8
leaq 0xeff6(%rip), %rsi      # 0x1e675
callq 0x3280
movq %rax, -0xd0(%rbp)
jmp 0xf68d
movq -0xd0(%rbp), %rdi
movq 0x16915(%rip), %rsi     # 0x25fb0
callq 0x32b0
jmp 0xf6a2
jmp 0xf6a4
leaq -0xb0(%rbp), %rdi
callq 0x14a90
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: mkTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
void mkTable(string tableName, int type, int returnType)//建立子符号表
{
    //新建一个subTableItem
    subTableItem newItem;
    
    //初始化subTableItem
    newItem.name = tableName;
    newItem.type = type;
    newItem.returnType = returnType;
    newItem.isValid = 1;//此表设为有效
    
    //将subTableItem插入符号表序列
    subTable.push_back(newItem);
    
    //修改当前符号表
    currentTable = tableName;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x14e00
movq -0x88(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3030
jmp 0xfd67
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movb $0x1, -0x20(%rbp)
leaq 0xafbca(%rip), %rdi     # 0xbf948
leaq -0x70(%rbp), %rsi
callq 0x14e40
jmp 0xfd89
movq -0x88(%rbp), %rsi
leaq 0xafbe1(%rip), %rdi     # 0xbf978
callq 0x3030
jmp 0xfd9e
leaq -0x70(%rbp), %rdi
callq 0x14eb0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x14eb0
movq -0x78(%rbp), %rdi
callq 0x3450
nop
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: arguments(int)
void arguments(int k)
{
	TreeNode tNode= tree.node[k];
	TreeNode childNode;
	
    if (lookahead(k) == 102)//102是(
    {
    	//code[currentLine].append("(");
        parameter_lists(tree.node[k].child[1]);
        //code[currentLine].append(")");
    }
    else if (lookahead(k) == 106)//e
    {}
    else
        cout<<"arguments error"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb6348(%rip), %rax     # 0xc6138
leaq 0x8(%rax,%rcx), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x14920
leaq -0x158(%rbp), %rdi
callq 0x149d0
movl -0x4(%rbp), %edi
callq 0xca50
movl %eax, -0x168(%rbp)
jmp 0xfe1d
movl -0x168(%rbp), %eax
cmpl $0x66, %eax
jne 0xfe73
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb62fe(%rip), %rax     # 0xc6138
movl 0x10(%rax,%rcx), %edi
callq 0xff00
jmp 0xfe45
jmp 0xfec5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
jmp 0xfee6
movl -0x4(%rbp), %edi
callq 0xca50
movl %eax, -0x16c(%rbp)
jmp 0xfe83
movl -0x16c(%rbp), %eax
cmpl $0x6a, %eax
jne 0xfe90
jmp 0xfec3
movq 0x16131(%rip), %rdi     # 0x25fc8
leaq 0xe844(%rip), %rsi      # 0x1e6e2
callq 0x3280
movq %rax, -0x178(%rbp)
jmp 0xfeac
movq -0x178(%rbp), %rdi
movq 0x160f6(%rip), %rsi     # 0x25fb0
callq 0x32b0
jmp 0xfec1
jmp 0xfec3
jmp 0xfec5
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0x160(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: parameter_lists(int)
void parameter_lists(int k)
{
    if (lookahead(k) == 17)//17是parameter_list
    {
        parameter_list(tree.node[k].child[0]);
        
        parameter_lists1(tree.node[k].child[1]);
    }
    else
        cout<<"parameter_lists error"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0xca50
cmpl $0x11, %eax
jne 0xff5c
movslq -0x4(%rbp), %rcx
leaq 0xb6215(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %edi
callq 0xff90
movslq -0x4(%rbp), %rcx
leaq 0xb61f4(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edi
callq 0x101a0
jmp 0xff7e
movq 0x16065(%rip), %rdi     # 0x25fc8
leaq 0xe788(%rip), %rsi      # 0x1e6f2
callq 0x3280
movq %rax, %rdi
movq 0x16037(%rip), %rsi     # 0x25fb0
callq 0x32b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: parameter_list(int)
void parameter_list(int k)
{
	TreeNode tNode= tree.node[k];
	TreeNode childNode;
	
    int idType;
    
    if(lookahead(k) == 107)//107是var
    {
        idType = type(tree.node[k].child[3]);
		code[currentLine].append(" ");
        identifier_list(idType, tree.node[k].child[1], 2);
    }
    else if(lookahead(k) == 2)//2是identifier_list
    {
        idType = type(tree.node[k].child[2]);
        code[currentLine].append(" ");
        identifier_list(idType, tree.node[k].child[0], 2);
    }
    else
        cout<<"parameter_list error!"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb6188(%rip), %rax     # 0xc6138
leaq 0x8(%rax,%rcx), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x14920
leaq -0x158(%rbp), %rdi
callq 0x149d0
movl -0x4(%rbp), %edi
callq 0xca50
movl %eax, -0x170(%rbp)
jmp 0xffdd
movl -0x170(%rbp), %eax
cmpl $0x6b, %eax
jne 0x1009a
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb613a(%rip), %rax     # 0xc6138
movl 0x18(%rax,%rcx), %edi
callq 0xeb50
movl %eax, -0x174(%rbp)
jmp 0x1000f
movl -0x174(%rbp), %eax
movl %eax, -0x15c(%rbp)
movslq 0xb05fe(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xaf973(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xe4c4(%rip), %rsi      # 0x1e4fb
callq 0x3490
jmp 0x1003e
movl -0x15c(%rbp), %edi
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb60e2(%rip), %rax     # 0xc6138
movl 0x10(%rax,%rcx), %esi
movl $0x2, %edx
callq 0xcd10
jmp 0x10066
jmp 0x10166
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x168(%rbp)
movl %eax, -0x16c(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
jmp 0x10187
movl -0x4(%rbp), %edi
callq 0xca50
movl %eax, -0x178(%rbp)
jmp 0x100aa
movl -0x178(%rbp), %eax
cmpl $0x2, %eax
jne 0x10131
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb6071(%rip), %rax     # 0xc6138
movl 0x14(%rax,%rcx), %edi
callq 0xeb50
movl %eax, -0x17c(%rbp)
jmp 0x100d8
movl -0x17c(%rbp), %eax
movl %eax, -0x15c(%rbp)
movslq 0xb0535(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xaf8aa(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xe3fb(%rip), %rsi      # 0x1e4fb
callq 0x3490
jmp 0x10107
movl -0x15c(%rbp), %edi
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb6019(%rip), %rax     # 0xc6138
movl 0xc(%rax,%rcx), %esi
movl $0x2, %edx
callq 0xcd10
jmp 0x1012f
jmp 0x10164
movq 0x15e90(%rip), %rdi     # 0x25fc8
leaq 0xe5e0(%rip), %rsi      # 0x1e71f
callq 0x3280
movq %rax, -0x188(%rbp)
jmp 0x1014d
movq -0x188(%rbp), %rdi
movq 0x15e55(%rip), %rsi     # 0x25fb0
callq 0x32b0
jmp 0x10162
jmp 0x10164
jmp 0x10166
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq -0x168(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: parameter_lists1(int)
void parameter_lists1(int k)
{
	TreeNode tNode= tree.node[k];
	TreeNode childNode;
    if (lookahead(k) == 104)//104是;
    {
        parameter_list(tree.node[k].child[1]);
        
        parameter_lists1(tree.node[k].child[2]);
    }
    else if (lookahead(k) == 106)//e
    {}
    else
        cout<<"parameter_lists' error"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb5f78(%rip), %rax     # 0xc6138
leaq 0x8(%rax,%rcx), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x14920
leaq -0x158(%rbp), %rdi
callq 0x149d0
movl -0x4(%rbp), %edi
callq 0xca50
movl %eax, -0x168(%rbp)
jmp 0x101ed
movl -0x168(%rbp), %eax
cmpl $0x68, %eax
jne 0x10260
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb5f2e(%rip), %rax     # 0xc6138
movl 0x10(%rax,%rcx), %edi
callq 0xff90
jmp 0x10215
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb5f11(%rip), %rax     # 0xc6138
movl 0x14(%rax,%rcx), %edi
callq 0x101a0
jmp 0x10232
jmp 0x102b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
jmp 0x102d3
movl -0x4(%rbp), %edi
callq 0xca50
movl %eax, -0x16c(%rbp)
jmp 0x10270
movl -0x16c(%rbp), %eax
cmpl $0x6a, %eax
jne 0x1027d
jmp 0x102b0
movq 0x15d44(%rip), %rdi     # 0x25fc8
leaq 0xe47d(%rip), %rsi      # 0x1e708
callq 0x3280
movq %rax, -0x178(%rbp)
jmp 0x10299
movq -0x178(%rbp), %rdi
movq 0x15d09(%rip), %rsi     # 0x25fb0
callq 0x32b0
jmp 0x102ae
jmp 0x102b0
jmp 0x102b2
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0x160(%rbp), %rdi
callq 0x3450
nop
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: optional_statements(int)
void optional_statements(int k)
{
    if(lookahead(k) == 20)//20是statement_list
    {
        statement_list(tree.node[k].child[0]);
    }
    else if (lookahead(k) == 106)//e
    {}
    else
        cout<<"optional_statements error!"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0xca50
cmpl $0x14, %eax
jne 0x1031b
movslq -0x4(%rbp), %rcx
leaq 0xb5e35(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %edi
callq 0x10360
jmp 0x1034e
movl -0x4(%rbp), %edi
callq 0xca50
cmpl $0x6a, %eax
jne 0x1032a
jmp 0x1034c
movq 0x15c97(%rip), %rdi     # 0x25fc8
leaq 0xe417(%rip), %rsi      # 0x1e74f
callq 0x3280
movq %rax, %rdi
movq 0x15c69(%rip), %rsi     # 0x25fb0
callq 0x32b0
jmp 0x1034e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: statement_list(int)
void statement_list(int k)
{
    if(lookahead(k) == 22)//22是statement
    {
        statement(tree.node[k].child[0]);
    
        statement_list1(tree.node[k].child[1]);
    }
    else
        cout<<"statement_list error!"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0xca50
cmpl $0x16, %eax
jne 0x103bc
movslq -0x4(%rbp), %rcx
leaq 0xb5db5(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %edi
callq 0x103f0
movslq -0x4(%rbp), %rcx
leaq 0xb5d94(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edi
callq 0x10b50
jmp 0x103de
movq 0x15c05(%rip), %rdi     # 0x25fc8
leaq 0xe3a0(%rip), %rsi      # 0x1e76a
callq 0x3280
movq %rax, %rdi
movq 0x15bd7(%rip), %rsi     # 0x25fb0
callq 0x32b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: statement_list1(int)
void statement_list1(int k)
{
    if(lookahead(k) == 104)//104是;
    {
        statement(tree.node[k].child[1]);
        
        statement_list1(tree.node[k].child[2]);
    }
    else if (lookahead(k) == 106)//e
    {}
    else
        cout<<"statement_list' error!"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0xca50
cmpl $0x68, %eax
jne 0x10bac
movslq -0x4(%rbp), %rcx
leaq 0xb55c5(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edi
callq 0x103f0
movslq -0x4(%rbp), %rcx
leaq 0xb55a4(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %edi
callq 0x10b50
jmp 0x10bdf
movl -0x4(%rbp), %edi
callq 0xca50
cmpl $0x6a, %eax
jne 0x10bbb
jmp 0x10bdd
movq 0x15406(%rip), %rdi     # 0x25fc8
leaq 0xdbb7(%rip), %rsi      # 0x1e780
callq 0x3280
movq %rax, %rdi
movq 0x153d8(%rip), %rsi     # 0x25fb0
callq 0x32b0
jmp 0x10bdf
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: expression_list(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int expression_list(int k,int useFlag, string idValue)
{
    int flag1, flag2;
    
    if(lookahead(k) == 29)//29是expression
    {
        flag1 = expression(tree.node[k].child[0],useFlag);
        if (useFlag == 3)//说明是函数调用，将读到的表达式类型(实参类型)记录在procArgument里面
        {
            procArgument.push_back(flag1);
        }

        flag2 = expression_list1(tree.node[k].child[1],useFlag);

        if (flag1 != -1 && flag2 != -1)//都不是-1
            return flag1;
        else
        {
            cout<<"type not match where expression_list"<<endl;
            return -1;
        }
    }
    else
    {
        cout<<"expr_list error!"<<endl;
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
callq 0xca50
cmpl $0x1d, %eax
jne 0x113b6
movslq -0x8(%rbp), %rcx
leaq 0xb4e1a(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %edi
movl -0xc(%rbp), %esi
callq 0x11130
movl %eax, -0x1c(%rbp)
cmpl $0x3, -0xc(%rbp)
jne 0x11350
leaq 0xae619(%rip), %rdi     # 0xbf960
leaq -0x1c(%rbp), %rsi
callq 0x14d90
movslq -0x8(%rbp), %rcx
leaq 0xb4ddd(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edi
movl -0xc(%rbp), %esi
callq 0x11b90
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x1138b
cmpl $-0x1, -0x20(%rbp)
je 0x1138b
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x113df
movq 0x14c36(%rip), %rdi     # 0x25fc8
leaq 0xd5f9(%rip), %rsi      # 0x1e992
callq 0x3280
movq %rax, %rdi
movq 0x14c08(%rip), %rsi     # 0x25fb0
callq 0x32b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x113df
movq 0x14c0b(%rip), %rdi     # 0x25fc8
leaq 0xd5f3(%rip), %rsi      # 0x1e9b7
callq 0x3280
movq %rax, %rdi
movq 0x14bdd(%rip), %rsi     # 0x25fb0
callq 0x32b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: variable1(int)
void variable1(int k)
{
	TreeNode tNode= tree.node[k];
	TreeNode childNode;
    if(lookahead(k) == 110)//110是[
    {
    	code[currentLine].append("[");
        if(expression(tree.node[k].child[1], 0) == 1)//下标必须是整数,expression里面标志位为0对吗
        {
            //[]内类型正确
            code[currentLine].append("]");
        }
        else
        {
            cout<<"subscript wrong where variable1"<<endl;//数组下标错误
        }
    }
    else if(lookahead(k) == 106)//106是e
    {

    }
    else
    {
        cout<<"variable' error!"<<endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb4d28(%rip), %rax     # 0xc6138
leaq 0x8(%rax,%rcx), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x14920
leaq -0x158(%rbp), %rdi
callq 0x149d0
movl -0x4(%rbp), %edi
callq 0xca50
movl %eax, -0x168(%rbp)
jmp 0x1143d
movl -0x168(%rbp), %eax
cmpl $0x6e, %eax
jne 0x11528
movslq 0xaf1cd(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xae542(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xcde4(%rip), %rsi      # 0x1e24c
callq 0x3490
jmp 0x1146f
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb4cb7(%rip), %rax     # 0xc6138
movl 0x10(%rax,%rcx), %edi
xorl %esi, %esi
callq 0x11130
movl %eax, -0x16c(%rbp)
jmp 0x11494
movl -0x16c(%rbp), %eax
cmpl $0x1, %eax
jne 0x114f3
movslq 0xaf17a(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xae4ef(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xcd93(%rip), %rsi      # 0x1e24e
callq 0x3490
jmp 0x114c2
jmp 0x11526
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
jmp 0x1159b
movq 0x14ace(%rip), %rdi     # 0x25fc8
leaq 0xd386(%rip), %rsi      # 0x1e887
callq 0x3280
movq %rax, -0x178(%rbp)
jmp 0x1150f
movq -0x178(%rbp), %rdi
movq 0x14a93(%rip), %rsi     # 0x25fb0
callq 0x32b0
jmp 0x11524
jmp 0x11526
jmp 0x1157a
movl -0x4(%rbp), %edi
callq 0xca50
movl %eax, -0x17c(%rbp)
jmp 0x11538
movl -0x17c(%rbp), %eax
cmpl $0x6a, %eax
jne 0x11545
jmp 0x11578
movq 0x14a7c(%rip), %rdi     # 0x25fc8
leaq 0xd354(%rip), %rsi      # 0x1e8a7
callq 0x3280
movq %rax, -0x188(%rbp)
jmp 0x11561
movq -0x188(%rbp), %rdi
movq 0x14a41(%rip), %rsi     # 0x25fb0
callq 0x32b0
jmp 0x11576
jmp 0x11578
jmp 0x1157a
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq -0x160(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: expression1(int)
int expression1(int k)
{
	TreeNode tNode= tree.node[k];
	TreeNode childNode;
    if(lookahead(k) == 131)//131是relop
    {
    	relop(tNode.child[0]);
        return simple_expression(tree.node[k].child[1]);
    }
    else if (lookahead(k) == 106)//106是e
    {
        return 0;
    }
    else
    {
        cout<<"expression' error!"<<endl;
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movl %edi, -0x8(%rbp)
movslq -0x8(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb4028(%rip), %rax     # 0xc6138
leaq 0x8(%rax,%rcx), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x14920
leaq -0x158(%rbp), %rdi
callq 0x149d0
movl -0x8(%rbp), %edi
callq 0xca50
movl %eax, -0x16c(%rbp)
jmp 0x1213d
movl -0x16c(%rbp), %eax
cmpl $0x83, %eax
jne 0x121c1
movl -0xac(%rbp), %edi
callq 0x12270
jmp 0x12157
movslq -0x8(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb3fcf(%rip), %rax     # 0xc6138
movl 0x10(%rax,%rcx), %edi
callq 0x11dd0
movl %eax, -0x170(%rbp)
jmp 0x1217a
movl -0x170(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x168(%rbp)
jmp 0x12231
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
jmp 0x12255
movl -0x8(%rbp), %edi
callq 0xca50
movl %eax, -0x174(%rbp)
jmp 0x121d1
movl -0x174(%rbp), %eax
cmpl $0x6a, %eax
jne 0x121ef
movl $0x0, -0x4(%rbp)
movl $0x1, -0x168(%rbp)
jmp 0x12231
movq 0x13dd2(%rip), %rdi     # 0x25fc8
leaq 0xc841(%rip), %rsi      # 0x1ea3e
callq 0x3280
movq %rax, -0x180(%rbp)
jmp 0x1220b
movq -0x180(%rbp), %rdi
movq 0x13d97(%rip), %rsi     # 0x25fb0
callq 0x32b0
jmp 0x12220
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x168(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
movl -0x4(%rbp), %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0x160(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: relop(int)
void relop(int k)
{
	
	TreeNode tNode= tree.node[k];
	if(tNode.type==131)
    {
		if(tNode.value=="=")
        {
			code[currentLine].append(" == ");
		}
		else{
			code[currentLine].append(tNode.value);	
		}
	
	}
	else ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
leaq 0xb3eaf(%rip), %rsi     # 0xc6138
addq $0x8, %rsi
imulq $0xa8, %rax, %rax
addq %rax, %rsi
leaq -0xb0(%rbp), %rdi
callq 0x14920
cmpl $0x83, -0x5c(%rbp)
jne 0x12340
leaq -0x30(%rbp), %rdi
leaq 0xbf98(%rip), %rsi      # 0x1e253
callq 0xc770
movb %al, -0xbd(%rbp)
jmp 0x122c8
movb -0xbd(%rbp), %al
testb $0x1, %al
jne 0x122d4
jmp 0x1231c
movslq 0xae345(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xad6ba(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xc761(%rip), %rsi      # 0x1ea51
callq 0x3490
jmp 0x122f7
jmp 0x1233e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x14a90
jmp 0x123ab
movslq 0xae2fd(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xad672(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq -0x30(%rbp), %rsi
callq 0x34a0
jmp 0x1233c
jmp 0x1233e
jmp 0x12396
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb3de6(%rip), %rax     # 0xc6138
movl 0x5c(%rax,%rcx), %edx
movl %edx, -0xc8(%rbp)
movl 0xae2be(%rip), %edx     # 0xc0620
movl %edx, -0xc4(%rbp)
leaq 0x88(%rax,%rcx), %rdi
callq 0x30d0
movl -0xc8(%rbp), %esi
movl -0xc4(%rbp), %edx
movq %rax, %rcx
leaq 0xc6cb(%rip), %rdi      # 0x1ea56
xorl %eax, %eax
callq 0x3040
jmp 0x12394
jmp 0x12396
leaq -0xb0(%rbp), %rdi
callq 0x14a90
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: mulop(int)
void mulop(int k)
{
	TreeNode tNode= tree.node[k];
	if(tNode.type==133){
		if(tNode.value=="mod"){
			code[currentLine].append(" % ");
		}
		else if(tNode.value=="and"){
			code[currentLine].append(" && ");	
		}
		else{
			code[currentLine].append(" ");
			code[currentLine].append(tNode.value);
			code[currentLine].append(" ");
		}
	
	}	
	else ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
leaq 0xb3d5f(%rip), %rsi     # 0xc6138
addq $0x8, %rsi
imulq $0xa8, %rax, %rax
addq %rax, %rsi
leaq -0xb0(%rbp), %rdi
callq 0x14920
cmpl $0x85, -0x5c(%rbp)
jne 0x12524
leaq -0x30(%rbp), %rdi
leaq 0xbe15(%rip), %rsi      # 0x1e220
callq 0xc770
movb %al, -0xbd(%rbp)
jmp 0x12418
movb -0xbd(%rbp), %al
testb $0x1, %al
jne 0x12424
jmp 0x1246f
movslq 0xae1f5(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xad56a(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xc64b(%rip), %rsi      # 0x1ea8b
callq 0x3490
jmp 0x12447
jmp 0x12522
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x14a90
jmp 0x1258f
leaq -0x30(%rbp), %rdi
leaq 0xbb8a(%rip), %rsi      # 0x1e004
callq 0xc770
movb %al, -0xbe(%rbp)
jmp 0x12487
movb -0xbe(%rbp), %al
testb $0x1, %al
jne 0x12493
jmp 0x124b8
movslq 0xae186(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xad4fb(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xc5e0(%rip), %rsi      # 0x1ea8f
callq 0x3490
jmp 0x124b6
jmp 0x12520
movslq 0xae161(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xad4d6(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xc027(%rip), %rsi      # 0x1e4fb
callq 0x3490
jmp 0x124db
movslq 0xae13e(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xad4b3(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq -0x30(%rbp), %rsi
callq 0x34a0
jmp 0x124fb
movslq 0xae11e(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xad493(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xbfe4(%rip), %rsi      # 0x1e4fb
callq 0x3490
jmp 0x1251e
jmp 0x12520
jmp 0x12522
jmp 0x1257a
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb3c02(%rip), %rax     # 0xc6138
movl 0x5c(%rax,%rcx), %edx
movl %edx, -0xc8(%rbp)
movl 0xae0da(%rip), %edx     # 0xc0620
movl %edx, -0xc4(%rbp)
leaq 0x88(%rax,%rcx), %rdi
callq 0x30d0
movl -0xc8(%rbp), %esi
movl -0xc4(%rbp), %edx
movq %rax, %rcx
leaq 0xc4e7(%rip), %rdi      # 0x1ea56
xorl %eax, %eax
callq 0x3040
jmp 0x12578
jmp 0x1257a
leaq -0xb0(%rbp), %rdi
callq 0x14a90
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x3450
nopl (%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: term(int)
int term(int k)
{
    int flag1, flag2;
    if(lookahead(k) == 35)//35是factor
    {
        flag1 = factor(tree.node[k].child[0]);
        
        flag2 = term1(tree.node[k].child[1]);
        
        if (flag1 >= flag2)
            return flag1;
        else if (flag1 <= flag2)
            return flag2;
        else
        {
            cout<<"type not match where term"<<endl;
            return -1;
        }
    }
    else
    {
        cout<<"term error!"<<endl;
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0xca50
cmpl $0x23, %eax
jne 0x1264f
movslq -0x8(%rbp), %rcx
leaq 0xb3b71(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %edi
callq 0x12c40
movl %eax, -0xc(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0xb3b4d(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edi
callq 0x132a0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0x12614
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12678
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x12624
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12678
movq 0x1399d(%rip), %rdi     # 0x25fc8
leaq 0xc4de(%rip), %rsi      # 0x1eb10
callq 0x3280
movq %rax, %rdi
movq 0x1396f(%rip), %rsi     # 0x25fb0
callq 0x32b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12678
movq 0x13972(%rip), %rdi     # 0x25fc8
leaq 0xc4cd(%rip), %rsi      # 0x1eb2a
callq 0x3280
movq %rax, %rdi
movq 0x13944(%rip), %rsi     # 0x25fb0
callq 0x32b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: sign(int)
int sign(int k)
{
	TreeNode tNode= tree.node[k];
	TreeNode childNode;
	childNode=tree.node[tNode.child[0]];
	if(childNode.type==137){
		code[currentLine].append("+");
	}
	else if(childNode.type==138){
		code[currentLine].append("-");
	}
	else 
	{
	}
    return 0;//这个返回可以吗
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb3848(%rip), %rax     # 0xc6138
movq %rax, -0x178(%rbp)
leaq 0x8(%rax,%rcx), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x14920
leaq -0x158(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x149d0
movq -0x178(%rbp), %rax
movq -0x170(%rbp), %rdi
movslq -0xac(%rbp), %rcx
imulq $0xa8, %rcx, %rcx
leaq 0x8(%rax,%rcx), %rsi
callq 0x14a10
jmp 0x12943
cmpl $0x89, -0x104(%rbp)
jne 0x129a0
movslq 0xadcca(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xad03f(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xb8f7(%rip), %rsi      # 0x1e262
callq 0x3490
jmp 0x12972
jmp 0x129d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
jmp 0x129f8
cmpl $0x8a, -0x104(%rbp)
jne 0x129d1
movslq 0xadc6d(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xacfe2(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xb89c(%rip), %rsi      # 0x1e264
callq 0x3490
jmp 0x129cf
jmp 0x129d3
jmp 0x129d3
jmp 0x129d5
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
xorl %eax, %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0x160(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: addop(int)
int addop(int k)
{
	TreeNode tNode= tree.node[k];
	TreeNode childNode;
	if(tNode.type==38){
		if(tNode.childNum>0){
			childNode=tree.node[tNode.child[0]];
			if(childNode.type==137){
				code[currentLine].append("+");
			}
			else if(childNode.type==138){
				code[currentLine].append("-");
			}
			else if(childNode.type==132){
				code[currentLine].append("or");
			}
			else 
				ERROR;
		}
	}
	else
		 ERROR;
    return 0;//返回对吗
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
leaq 0xb370f(%rip), %rsi     # 0xc6138
addq $0x8, %rsi
imulq $0xa8, %rax, %rax
addq %rax, %rsi
leaq -0xb0(%rbp), %rdi
callq 0x14920
leaq -0x158(%rbp), %rdi
callq 0x149d0
cmpl $0x26, -0x5c(%rbp)
jne 0x12bb4
cmpl $0x0, -0xb0(%rbp)
jle 0x12bb2
movslq -0xac(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb36bd(%rip), %rax     # 0xc6138
leaq 0x8(%rax,%rcx), %rsi
leaq -0x158(%rbp), %rdi
callq 0x14a10
jmp 0x12a8e
cmpl $0x89, -0x104(%rbp)
jne 0x12af1
movslq 0xadb7f(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xacef4(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xb7ac(%rip), %rsi      # 0x1e262
callq 0x3490
jmp 0x12abd
jmp 0x12bb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
jmp 0x12c2d
cmpl $0x8a, -0x104(%rbp)
jne 0x12b25
movslq 0xadb1c(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xace91(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xb74b(%rip), %rsi      # 0x1e264
callq 0x3490
jmp 0x12b20
jmp 0x12bae
cmpl $0x84, -0x104(%rbp)
jne 0x12b56
movslq 0xadae8(%rip), %rax     # 0xc0620
shlq $0x5, %rax
leaq 0xace5d(%rip), %rdi     # 0xbf9a0
addq %rax, %rdi
leaq 0xbbcf(%rip), %rsi      # 0x1e71c
callq 0x3490
jmp 0x12b54
jmp 0x12bac
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb35d0(%rip), %rax     # 0xc6138
movl 0x5c(%rax,%rcx), %edx
movl %edx, -0x16c(%rbp)
movl 0xadaa8(%rip), %edx     # 0xc0620
movl %edx, -0x168(%rbp)
leaq 0x88(%rax,%rcx), %rdi
callq 0x30d0
movl -0x16c(%rbp), %esi
movl -0x168(%rbp), %edx
movq %rax, %rcx
leaq 0xbeb5(%rip), %rdi      # 0x1ea56
xorl %eax, %eax
callq 0x3040
jmp 0x12baa
jmp 0x12bac
jmp 0x12bae
jmp 0x12bb0
jmp 0x12bb2
jmp 0x12c0a
movslq -0x4(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb3572(%rip), %rax     # 0xc6138
movl 0x5c(%rax,%rcx), %edx
movl %edx, -0x174(%rbp)
movl 0xada4a(%rip), %edx     # 0xc0620
movl %edx, -0x170(%rbp)
leaq 0x88(%rax,%rcx), %rdi
callq 0x30d0
movl -0x174(%rbp), %esi
movl -0x170(%rbp), %edx
movq %rax, %rcx
leaq 0xbe57(%rip), %rdi      # 0x1ea56
xorl %eax, %eax
callq 0x3040
jmp 0x12c08
jmp 0x12c0a
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
xorl %eax, %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0x160(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: term1(int)
int term1(int k)
{
	TreeNode tNode= tree.node[k];
	TreeNode childNode;
	
    int flag1, flag2;
    if(lookahead(k) == 133)//133是mulop
    {
    	mulop(tNode.child[0]);
        
        flag1 = factor(tree.node[k].child[1]);
        
        flag2 = term1(tree.node[k].child[2]);
        
        if (flag1 >= flag2)
            return flag1;
        else if (flag1 <= flag2)
            return flag2;
        else
        {
            cout<<"type not match where term'"<<endl;
            return -1;
        }
    }
    else if (lookahead(k) == 106)//106是e
    {
        return 0;//它可以是任意类型
    }
    else
    {
        cout<<"term' error!"<<endl;
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movl %edi, -0x8(%rbp)
movslq -0x8(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb2e78(%rip), %rax     # 0xc6138
leaq 0x8(%rax,%rcx), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x14920
leaq -0x158(%rbp), %rdi
callq 0x149d0
movl -0x8(%rbp), %edi
callq 0xca50
movl %eax, -0x174(%rbp)
jmp 0x132ed
movl -0x174(%rbp), %eax
cmpl $0x85, %eax
jne 0x13428
movl -0xac(%rbp), %edi
callq 0x123c0
jmp 0x1330b
movslq -0x8(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb2e1b(%rip), %rax     # 0xc6138
movl 0x10(%rax,%rcx), %edi
callq 0x12c40
movl %eax, -0x178(%rbp)
jmp 0x1332e
movl -0x178(%rbp), %eax
movl %eax, -0x15c(%rbp)
movslq -0x8(%rbp), %rax
imulq $0xa8, %rax, %rcx
leaq 0xb2dec(%rip), %rax     # 0xc6138
movl 0x14(%rax,%rcx), %edi
callq 0x132a0
movl %eax, -0x17c(%rbp)
jmp 0x1335d
movl -0x17c(%rbp), %eax
movl %eax, -0x160(%rbp)
movl -0x15c(%rbp), %eax
cmpl -0x160(%rbp), %eax
jl 0x133be
movl -0x15c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x170(%rbp)
jmp 0x13498
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x168(%rbp)
movl %eax, -0x16c(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
jmp 0x134bc
movl -0x15c(%rbp), %eax
cmpl -0x160(%rbp), %eax
jg 0x133e4
movl -0x160(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x170(%rbp)
jmp 0x13498
movq 0x12bdd(%rip), %rdi     # 0x25fc8
leaq 0xb744(%rip), %rsi      # 0x1eb36
callq 0x3280
movq %rax, -0x188(%rbp)
jmp 0x13400
movq -0x188(%rbp), %rdi
movq 0x12ba2(%rip), %rsi     # 0x25fb0
callq 0x32b0
jmp 0x13415
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x170(%rbp)
jmp 0x13498
movl -0x8(%rbp), %edi
callq 0xca50
movl %eax, -0x18c(%rbp)
jmp 0x13438
movl -0x18c(%rbp), %eax
cmpl $0x6a, %eax
jne 0x13456
movl $0x0, -0x4(%rbp)
movl $0x1, -0x170(%rbp)
jmp 0x13498
movq 0x12b6b(%rip), %rdi     # 0x25fc8
leaq 0xb6ed(%rip), %rsi      # 0x1eb51
callq 0x3280
movq %rax, -0x198(%rbp)
jmp 0x13472
movq -0x198(%rbp), %rdi
movq 0x12b30(%rip), %rsi     # 0x25fb0
callq 0x32b0
jmp 0x13487
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x170(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x14a90
leaq -0xb0(%rbp), %rdi
callq 0x14a90
movl -0x4(%rbp), %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
movq -0x168(%rbp), %rdi
callq 0x3450
nopl (%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: checkFunReturnType(int)
int checkFunReturnType(int id_position)//返回函数返回类型
{
    for(vector<subTableItem>::iterator it = subTable.begin(); it != subTable.end();it++)
    {
        if (tree.node[id_position].value == it->name)//匹配到子表名字
        {
            return it->returnType;
            //break;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
leaq 0xabde6(%rip), %rdi     # 0xbf948
callq 0x14b00
movq %rax, -0x10(%rbp)
leaq 0xabdd6(%rip), %rdi     # 0xbf948
callq 0x14b70
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x14b30
testb $0x1, %al
jne 0x13b8e
jmp 0x13bf7
movslq -0x8(%rbp), %rcx
leaq 0xb259f(%rip), %rax     # 0xc6138
addq $0x8, %rax
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
addq $0x80, %rax
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x14ba0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x30, %rsi
callq 0xc840
testb $0x1, %al
jne 0x13bd0
jmp 0x13be1
leaq -0x10(%rbp), %rdi
callq 0x14ba0
movl 0x58(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x13bfe
jmp 0x13be3
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x14bc0
movq %rax, -0x20(%rbp)
jmp 0x13b6b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zhengwangsun[P]pas2c/semantics.cpp
// Function: showMainTbale()
void showMainTbale()//显示主表信息
{
    cout<<"MainTable:"<<endl;
    int i = 0;
    for(vector<Tuple>::iterator it = mainTable.begin(); it != mainTable.end();it++)
    {
        cout<<it->name<<"   "<<it->type<<"   line:"<<it->declareRow<<"   "<<endl;
        for (vector<int>::iterator it1 = it->useRow.begin(); it1 != it->useRow.end();it1++)
        {
            cout<<"              "<<it->useRow[i]<<endl;
            i++;
        }
        i = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x11d59(%rip), %rdi     # 0x25fc8
leaq 0xab1f(%rip), %rsi      # 0x1ed95
callq 0x3280
movq %rax, %rdi
movq 0x11d2b(%rip), %rsi     # 0x25fb0
callq 0x32b0
movl $0x0, -0x4(%rbp)
leaq 0xab698(%rip), %rdi     # 0xbf930
callq 0x14c50
movq %rax, -0x10(%rbp)
leaq 0xab688(%rip), %rdi     # 0xbf930
callq 0x14cc0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x14c80
testb $0x1, %al
jne 0x142c7
jmp 0x14414
leaq -0x10(%rbp), %rdi
callq 0x14cf0
movq %rax, %rsi
movq 0x11cee(%rip), %rdi     # 0x25fc8
callq 0x3260
movq %rax, %rdi
leaq 0xaacb(%rip), %rsi      # 0x1edb4
callq 0x3280
movq %rax, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x14cf0
movq -0x48(%rbp), %rdi
movl 0x20(%rax), %esi
callq 0x3440
movq %rax, %rdi
leaq 0xaa8f(%rip), %rsi      # 0x1eda0
callq 0x3280
movq %rax, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x14cf0
movq -0x40(%rbp), %rdi
movl 0x28(%rax), %esi
callq 0x3440
movq %rax, %rdi
leaq 0xaa7b(%rip), %rsi      # 0x1edb4
callq 0x3280
movq %rax, %rdi
movq 0x11c68(%rip), %rsi     # 0x25fb0
callq 0x32b0
leaq -0x10(%rbp), %rdi
callq 0x14cf0
movq %rax, %rdi
addq $0x30, %rdi
callq 0x14fc0
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x14cf0
movq %rax, %rdi
addq $0x30, %rdi
callq 0x15030
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14ff0
testb $0x1, %al
jne 0x14392
jmp 0x143f9
movq 0x11c2f(%rip), %rdi     # 0x25fc8
leaq 0xaa09(%rip), %rsi      # 0x1eda9
callq 0x3280
movq %rax, -0x50(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x14cf0
movq %rax, %rdi
addq $0x30, %rdi
movslq -0x4(%rbp), %rsi
callq 0x14d10
movq -0x50(%rbp), %rdi
movl (%rax), %esi
callq 0x3440
movq %rax, %rdi
movq 0x11bd9(%rip), %rsi     # 0x25fb0
callq 0x32b0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x15080
movq %rax, -0x30(%rbp)
jmp 0x14366
movl $0x0, -0x4(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x14d30
movq %rax, -0x38(%rbp)
jmp 0x142a1
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zhengwangsun[P]pas2c/grammar.cpp
// Function: GrammarAnalysis()
bool GrammarAnalysis()                 //语法分析 
{
	InitGeneration();                  //将文法生成式存入
	GetFirst();                        //求每一个生成式右部符号的FIRST集
	GetFollow();                       //求每一个生成式左部符号的FOLLOW集
	CreatAnalysisTable();              //创建LL(1)分析表
    GrammarOutput();                   //语法分析中间结果 
	if(Analyze())                      //调用LL(1)分析函数,判断分析结果 
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x17f60
callq 0x18a70
callq 0x18aa0
callq 0x18b00
callq 0x18cc0
callq 0x19980
testb $0x1, %al
jne 0x17f3c
jmp 0x17f42
movb $0x1, -0x1(%rbp)
jmp 0x17f46
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)