LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movl %edi, %ebp
callq 0x603d
cmpl $0x1d, %eax
jne 0x8ae5
movslq %ebp, %rax
imulq $0xa8, %rax, %rax
leaq 0xab610(%rip), %rcx     # 0xb4098
leaq (%rcx,%rax), %r14
addq $0xc, %r14
movl (%r14), %edi
movl %ebx, %esi
callq 0x8946
movl %eax, 0xc(%rsp)
cmpl $0x3, %ebx
jne 0x8ab4
leaq 0xa4e16(%rip), %rdi     # 0xad8c0
leaq 0xc(%rsp), %rsi
callq 0xa628
movl 0x4(%r14), %edi
movl %ebx, %esi
callq 0x8f36
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl $-0x1, %eax
setne %dl
cmpl $-0x1, %ecx
setne %cl
testb %dl, %cl
jne 0x8b03
movq 0xb4f4(%rip), %rdi      # 0x13fd0
leaq 0x5f75(%rip), %rsi      # 0xea58
jmp 0x8af3
movq 0xb4e4(%rip), %rdi      # 0x13fd0
leaq 0x5f8a(%rip), %rsi      # 0xea7d
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movslq %edi, %r14
imulq $0xa8, %r14, %rax
leaq 0xab571(%rip), %rcx     # 0xb4098
leaq (%rcx,%rax), %rbx
addq $0x8, %rbx
leaq 0xb0(%rsp), %rdi
movq %rbx, %rsi
callq 0xa562
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x98(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
movl %r14d, %edi
callq 0x603d
cmpl $0x6a, %eax
je 0x8be9
cmpl $0x6e, %eax
jne 0x8bc5
movslq 0xa5a03(%rip), %rdi     # 0xae580
shlq $0x5, %rdi
leaq 0xa4d78(%rip), %r14     # 0xad900
addq %r14, %rdi
leaq 0x5736(%rip), %rsi      # 0xe2c8
callq 0x2350
movl 0x8(%rbx), %edi
xorl %esi, %esi
callq 0x8946
cmpl $0x1, %eax
jne 0x8bce
movslq 0xa59d3(%rip), %rax     # 0xae580
shlq $0x5, %rax
addq %rax, %r14
leaq 0x570f(%rip), %rsi      # 0xe2ca
movq %r14, %rdi
callq 0x2350
jmp 0x8be9
leaq 0x5da1(%rip), %rsi      # 0xe96d
jmp 0x8bd5
leaq 0x5d78(%rip), %rsi      # 0xe94d
movq 0xb3f4(%rip), %rdi      # 0x13fd0
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0xa600
leaq 0xb0(%rsp), %rdi
callq 0xa600
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa600
leaq 0xb0(%rsp), %rdi
callq 0xa600
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/zhengwangsun[P]pas2c/semantics.cpp
// Function: expression_list1(int, int)
int expression_list1(int k,int useFlag)
{
	TreeNode tNode= tree.node[k];
	TreeNode childNode;
	
    int flag1, flag2;
    if(lookahead(k) == 105)//105是,
    {
    	code[currentLine].append(",");
        flag1 = expression(tree.node[k].child[1],useFlag);
        if (useFlag == 3)//说明是函数调用，将读到的表达式类型记录在procArgument里面
        {
            procArgument.push_back(flag1);
        }
        
        flag2 = expression_list1(tree.node[k].child[2],useFlag);
        
        if (flag1 != -1 && flag2 != -1)//都不是-1
            return flag1;//将flag1的值返回，剩下的可以再递归看
        else
        {
            cout<<"type not match where expression_list'"<<endl;
            return -1;
        }
    }
    else if(lookahead(k) == 106)//106是e
    {
        return 0;
    }
    else
    {
        cout<<"expr_list' error!"<<endl;
        return -1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movl %esi, %ebx
movslq %edi, %r15
imulq $0xa8, %r15, %rax
leaq 0xab142(%rip), %rcx     # 0xb4098
leaq (%rcx,%rax), %r14
addq $0x8, %r14
leaq 0xb0(%rsp), %rdi
movq %r14, %rsi
callq 0xa562
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ebp, %ebp
movb %bpl, (%rax)
leaq 0x98(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %bpl, (%rax)
movl %r15d, %edi
callq 0x603d
cmpl $0x6a, %eax
je 0x9037
cmpl $0x69, %eax
jne 0x9019
movslq 0xa55ce(%rip), %rax     # 0xae580
shlq $0x5, %rax
leaq 0xa4943(%rip), %rdi     # 0xad900
addq %rax, %rdi
leaq 0x5b0a(%rip), %rsi      # 0xead1
callq 0x2350
movl 0x8(%r14), %edi
movl %ebx, %esi
callq 0x8946
movl %eax, 0x4(%rsp)
cmpl $0x3, %ebx
jne 0x8ff1
leaq 0xa48d9(%rip), %rdi     # 0xad8c0
leaq 0x4(%rsp), %rsi
callq 0xa628
movl 0xc(%r14), %edi
movl %ebx, %esi
callq 0x8f36
movl 0x4(%rsp), %ebp
cmpl $-0x1, %ebp
setne %cl
cmpl $-0x1, %eax
setne %al
testb %cl, %al
jne 0x9037
leaq 0x5a77(%rip), %rsi      # 0xea8e
jmp 0x9020
leaq 0x5a94(%rip), %rsi      # 0xeab4
movq 0xafa9(%rip), %rdi      # 0x13fd0
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
pushq $-0x1
popq %rbp
leaq 0x8(%rsp), %rdi
callq 0xa600
leaq 0xb0(%rsp), %rdi
callq 0xa600
movl %ebp, %eax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa600
leaq 0xb0(%rsp), %rdi
callq 0xa600
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/zhengwangsun[P]pas2c/semantics.cpp
// Function: simple_expression(int)
int simple_expression(int k)
{
	TreeNode tNode= tree.node[k];
	TreeNode childNode;
    int flag1, flag2;
    if(lookahead(k) == 33)//33是term
    {
        flag1 = term(tree.node[k].child[0]);
        
        flag2 = simple_expression1(tree.node[k].child[1]);
        
        if (flag1 >= flag2)
            return flag1;
        else if (flag1 <= flag2)
            return flag2;
        else
        {
            cout<<"type not match where simple_expression"<<endl;
            return -1;
        }
    }
    else if (lookahead(k) == 37)//37是sign
    {
        sign(tree.node[k].child[0]);
        
        flag1 = term(tree.node[k].child[1]);
        
        flag2 = simple_expression1(tree.node[k].child[2]);
        
        if (flag1 >= flag2)
            return flag1;
        else if (flag1 <= flag2)
            return flag2;
        else
        {
            cout<<"type not match where simple_expression"<<endl;
            return -1;
        }
    }
    else
    {
        cout<<"simple_expression error!"<<endl;
        return -1;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movslq %edi, %r14
imulq $0xa8, %r14, %rax
leaq 0xaaffc(%rip), %rcx     # 0xb4098
leaq (%rcx,%rax), %rbx
addq $0x8, %rbx
leaq 0xa8(%rsp), %rdi
movq %rbx, %rsi
callq 0xa562
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x90(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
movl %r14d, %edi
callq 0x603d
cmpl $0x25, %eax
je 0x90ff
cmpl $0x21, %eax
jne 0x9122
movl 0x4(%rbx), %edi
callq 0x9468
movl %eax, %ebp
movl 0x8(%rbx), %edi
callq 0x94cb
jmp 0x9119
movl 0x4(%rbx), %edi
callq 0x95bf
movl 0x8(%rbx), %edi
callq 0x9468
movl %eax, %ebp
movl 0xc(%rbx), %edi
callq 0x94cb
movl %eax, %ebx
cmpl %eax, %ebp
cmovgl %ebp, %ebx
jmp 0x9140
movq 0xaea7(%rip), %rdi      # 0x13fd0
leaq 0x5a0a(%rip), %rsi      # 0xeb3a
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
pushq $-0x1
popq %rbx
movq %rsp, %rdi
callq 0xa600
leaq 0xa8(%rsp), %rdi
callq 0xa600
movl %ebx, %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa600
leaq 0xa8(%rsp), %rdi
callq 0xa600
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movslq %edi, %r14
imulq $0xa8, %r14, %rax
leaq 0xaaef9(%rip), %rcx     # 0xb4098
leaq (%rcx,%rax), %rbx
addq $0x8, %rbx
leaq 0xa8(%rsp), %rdi
movq %rbx, %rsi
callq 0xa562
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ebp, %ebp
movb %bpl, (%rax)
leaq 0x90(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %bpl, (%rax)
movl %r14d, %edi
callq 0x603d
cmpl $0x6a, %eax
je 0x9228
cmpl $0x83, %eax
jne 0x920a
movl 0xac(%rsp), %edi
callq 0x926b
movl 0x8(%rbx), %edi
callq 0x9080
movl %eax, %ebp
jmp 0x9228
movq 0xadbf(%rip), %rdi      # 0x13fd0
leaq 0x58cc(%rip), %rsi      # 0xeae4
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
pushq $-0x1
popq %rbp
movq %rsp, %rdi
callq 0xa600
leaq 0xa8(%rsp), %rdi
callq 0xa600
movl %ebp, %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa600
leaq 0xa8(%rsp), %rdi
callq 0xa600
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0xa8, %rsp
movslq %edi, %rax
imulq $0xa8, %rax, %rax
leaq 0xaae12(%rip), %rcx     # 0xb4098
leaq (%rcx,%rax), %rbx
addq $0x8, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa562
cmpl $0x83, 0x54(%r14)
jne 0x92e4
leaq 0x80(%rsp), %rbx
leaq 0x501a(%rip), %rsi      # 0xe2cf
movq %rbx, %rdi
callq 0x5f92
movslq 0xa52bc(%rip), %rcx     # 0xae580
shlq $0x5, %rcx
leaq 0xa4631(%rip), %rdi     # 0xad900
addq %rcx, %rdi
testb %al, %al
je 0x9304
leaq 0x581a(%rip), %rsi      # 0xeaf7
callq 0x2350
jmp 0x930c
movl 0x54(%rbx), %esi
movl 0xa5293(%rip), %edx     # 0xae580
movq 0x80(%rbx), %rcx
leaq 0x5801(%rip), %rdi      # 0xeafc
xorl %eax, %eax
callq 0x2030
jmp 0x930c
movq %rbx, %rsi
callq 0x2370
movq %rsp, %rdi
callq 0xa600
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa600
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movslq %edi, %rax
imulq $0xa8, %rax, %rax
leaq 0xaad49(%rip), %rcx     # 0xb4098
leaq (%rcx,%rax), %rbx
addq $0x8, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa562
cmpl $0x85, 0x54(%r14)
jne 0x93ad
leaq 0x88(%rsp), %rbx
leaq 0x4f1c(%rip), %rsi      # 0xe29c
movq %rbx, %rdi
callq 0x5f92
testb %al, %al
je 0x93cd
movslq 0xa51ed(%rip), %rax     # 0xae580
shlq $0x5, %rax
leaq 0xa4562(%rip), %rdi     # 0xad900
addq %rax, %rdi
leaq 0x5789(%rip), %r14      # 0xeb31
jmp 0x9434
movl 0x54(%rbx), %esi
movl 0xa51ca(%rip), %edx     # 0xae580
movq 0x80(%rbx), %rcx
leaq 0x5738(%rip), %rdi      # 0xeafc
xorl %eax, %eax
callq 0x2030
jmp 0x943c
leaq 0x4c30(%rip), %rsi      # 0xe004
movq %rbx, %rdi
callq 0x5f92
movslq 0xa519d(%rip), %rdi     # 0xae580
shlq $0x5, %rdi
leaq 0xa4512(%rip), %r15     # 0xad900
addq %r15, %rdi
testb %al, %al
je 0x93fe
leaq 0x5739(%rip), %r14      # 0xeb35
jmp 0x9434
leaq 0x51bc(%rip), %r14      # 0xe5c1
movq %r14, %rsi
callq 0x2350
movslq 0xa516c(%rip), %rdi     # 0xae580
shlq $0x5, %rdi
addq %r15, %rdi
movq %rbx, %rsi
callq 0x2370
movslq 0xa5156(%rip), %rax     # 0xae580
shlq $0x5, %rax
addq %rax, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2350
leaq 0x8(%rsp), %rdi
callq 0xa600
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa600
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0x603d
cmpl $0x23, %eax
jne 0x94a7
movslq %ebx, %rax
imulq $0xa8, %rax, %r14
leaq 0xaac0e(%rip), %r15     # 0xb4098
movl 0xc(%r15,%r14), %edi
callq 0x97f7
movl %eax, %ebx
movl 0x10(%r15,%r14), %edi
callq 0x9b1d
cmpl %eax, %ebx
cmovgl %ebx, %eax
jmp 0x94c5
movq 0xab22(%rip), %rdi      # 0x13fd0
leaq 0x56b2(%rip), %rsi      # 0xeb67
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/zhengwangsun[P]pas2c/semantics.cpp
// Function: simple_expression1(int)
int simple_expression1(int k)
{
	TreeNode tNode= tree.node[k];
	TreeNode childNode;
	
    int flag1, flag2;
    if(lookahead(k) == 38)//38是addop
    {
        addop(tree.node[k].child[0]);
        
        flag1 = term(tree.node[k].child[1]);
        
        flag2 = simple_expression1(tree.node[k].child[2]);
        
        if (flag1 >= flag2)
            return flag1;
        else if (flag1 <= flag2)
            return flag2;
        else
        {
            cout<<"type not match where simple_expression1"<<endl;
            return -1;
        }
    }
    else if (lookahead(k) == 106)//106是e
    {
        return 0;//说明它是任意类型
    }
    else
    {
        cout<<"simple_expr' error!"<<endl;
        return -1;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movslq %edi, %r14
imulq $0xa8, %r14, %rax
leaq 0xaabb1(%rip), %rcx     # 0xb4098
leaq (%rcx,%rax), %rbx
addq $0x8, %rbx
leaq 0xa8(%rsp), %rdi
movq %rbx, %rsi
callq 0xa562
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ebp, %ebp
movb %bpl, (%rax)
leaq 0x90(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %bpl, (%rax)
movl %r14d, %edi
callq 0x603d
cmpl $0x6a, %eax
je 0x957c
cmpl $0x26, %eax
jne 0x955e
movl 0x4(%rbx), %edi
callq 0x96b6
movl 0x8(%rbx), %edi
callq 0x9468
movl %eax, %r14d
movl 0xc(%rbx), %edi
callq 0x94cb
movl %eax, %ebp
cmpl %eax, %r14d
cmovgl %r14d, %ebp
jmp 0x957c
movq 0xaa6b(%rip), %rdi      # 0x13fd0
leaq 0x55e7(%rip), %rsi      # 0xeb53
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
pushq $-0x1
popq %rbp
movq %rsp, %rdi
callq 0xa600
leaq 0xa8(%rsp), %rdi
callq 0xa600
movl %ebp, %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa600
leaq 0xa8(%rsp), %rdi
callq 0xa600
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movslq %edi, %rax
imulq $0xa8, %rax, %rax
leaq 0xaaabe(%rip), %r14     # 0xb4098
leaq (%r14,%rax), %rsi
addq $0x8, %rsi
leaq 0xb0(%rsp), %rbx
movq %rbx, %rdi
callq 0xa562
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x98(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
movslq 0x4(%rbx), %rax
imulq $0xa8, %rax, %rax
leaq (%r14,%rax), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %rdi
callq 0xa5ba
movl 0x5c(%rsp), %eax
cmpl $0x89, %eax
je 0x964f
cmpl $0x8a, %eax
jne 0x9670
leaq 0x4c93(%rip), %rsi      # 0xe2e0
jmp 0x9656
leaq 0x4c88(%rip), %rsi      # 0xe2de
movslq 0xa4f23(%rip), %rax     # 0xae580
shlq $0x5, %rax
leaq 0xa4298(%rip), %rdi     # 0xad900
addq %rax, %rdi
callq 0x2350
leaq 0x8(%rsp), %rdi
callq 0xa600
leaq 0xb0(%rsp), %rdi
callq 0xa600
xorl %eax, %eax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa600
leaq 0xb0(%rsp), %rdi
callq 0xa600
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movslq %edi, %rax
imulq $0xa8, %rax, %rax
leaq 0xaa9c5(%rip), %r15     # 0xb4098
leaq (%r15,%rax), %rbx
addq $0x8, %rbx
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa562
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x90(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
cmpl $0x26, 0x54(%r14)
jne 0x9769
cmpl $0x0, 0xa8(%rsp)
jle 0x97b3
movslq 0xac(%rsp), %rax
imulq $0xa8, %rax, %rax
leaq (%r15,%rax), %rsi
addq $0x8, %rsi
movq %rsp, %rdi
callq 0xa5ba
movl 0x54(%rsp), %eax
cmpl $0x84, %eax
je 0x9792
cmpl $0x89, %eax
je 0x9789
cmpl $0x8a, %eax
jne 0x9769
leaq 0x4b79(%rip), %rsi      # 0xe2e0
jmp 0x9799
movl 0x54(%rbx), %esi
movl 0xa4e0e(%rip), %edx     # 0xae580
movq 0x80(%rbx), %rcx
leaq 0x537c(%rip), %rdi      # 0xeafc
xorl %eax, %eax
callq 0x2030
jmp 0x97b3
leaq 0x4b4e(%rip), %rsi      # 0xe2de
jmp 0x9799
leaq 0x5049(%rip), %rsi      # 0xe7e2
movslq 0xa4de0(%rip), %rax     # 0xae580
shlq $0x5, %rax
leaq 0xa4155(%rip), %rdi     # 0xad900
addq %rax, %rdi
callq 0x2350
movq %rsp, %rdi
callq 0xa600
leaq 0xa8(%rsp), %rdi
callq 0xa600
xorl %eax, %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa600
leaq 0xa8(%rsp), %rdi
callq 0xa600
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movslq %edi, %r14
imulq $0xa8, %r14, %rax
leaq 0xaa55f(%rip), %rcx     # 0xb4098
leaq (%rcx,%rax), %rbx
addq $0x8, %rbx
leaq 0xa8(%rsp), %rdi
movq %rbx, %rsi
callq 0xa562
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ebp, %ebp
movb %bpl, (%rax)
leaq 0x90(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %bpl, (%rax)
movl %r14d, %edi
callq 0x603d
cmpl $0x6a, %eax
je 0x9bd4
cmpl $0x85, %eax
jne 0x9bb6
movl 0xac(%rsp), %edi
callq 0x9332
movl 0x8(%rbx), %edi
callq 0x97f7
movl %eax, %r14d
movl 0xc(%rbx), %edi
callq 0x9b1d
movl %eax, %ebp
cmpl %eax, %r14d
cmovgl %r14d, %ebp
jmp 0x9bd4
movq 0xa413(%rip), %rdi      # 0x13fd0
leaq 0x4faf(%rip), %rsi      # 0xeb73
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
pushq $-0x1
popq %rbp
movq %rsp, %rdi
callq 0xa600
leaq 0xa8(%rsp), %rdi
callq 0xa600
movl %ebp, %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa600
leaq 0xa8(%rsp), %rdi
callq 0xa600
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/zhengwangsun[P]pas2c/semantics.cpp
// Function: getIdTuple(int)
Tuple getIdTuple(int id_position)
{
    if(currentTable == "main")
    {
        for(vector<Tuple>::iterator it = mainTable.begin(); it != mainTable.end();it++)//遍历查重
        {
            if(it->name == tree.node[id_position].value)
            {
                return *it;
            }
        }
    }
    else
    {
        for(vector<subTableItem>::iterator it = subTable.begin(); it != subTable.end();it++)
        {
            if(it->name == currentTable)//找到当前子表
            {
                for(vector<Tuple>::iterator it0 = it->item.begin(); it0 != it->item.end();it0++)//遍历子表中的item
                {
                    if(it0->name == tree.node[id_position].value)
                    {
                        return *it0;
                    }
                }
            }
        }
    }
    
    Tuple errorTuple;
    errorTuple.name = "error!";
    return errorTuple;
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xa38a3(%rip), %rdi     # 0xad8d8
leaq 0x4544(%rip), %rsi      # 0xe580
callq 0x5f92
movslq %ebp, %rcx
imulq $0xa8, %rcx, %rcx
leaq 0xaa046(%rip), %rdx     # 0xb4098
leaq (%rdx,%rcx), %r14
addq $0x88, %r14
testb %al, %al
je 0xa086
movq 0xa3828(%rip), %r15     # 0xad890
cmpq 0xa3829(%rip), %r15     # 0xad898
je 0xa0df
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f9f
testb %al, %al
jne 0xa0d2
addq $0x50, %r15
jmp 0xa068
movq 0xa381b(%rip), %r13     # 0xad8a8
leaq 0xa3844(%rip), %r12     # 0xad8d8
cmpq 0xa3815(%rip), %r13     # 0xad8b0
je 0xa0df
leaq 0x30(%r13), %rdi
movq %r12, %rsi
callq 0x5f9f
testb %al, %al
je 0xa0cc
movq (%r13), %r15
cmpq 0x8(%r13), %r15
je 0xa0cc
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f9f
testb %al, %al
jne 0xa0d2
addq $0x50, %r15
jmp 0xa0b1
addq $0x60, %r13
jmp 0xa094
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa6d4
jmp 0xa10a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
andq $0x0, 0x40(%rbx)
leaq 0x4875(%rip), %rsi      # 0xe977
movq %rbx, %rdi
callq 0x2360
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa6be
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x9d3e(%rip), %rbx      # 0x13fd0
leaq 0x4b1e(%rip), %rsi      # 0xedb7
movq %rbx, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
movq 0xa35e0(%rip), %r14     # 0xad890
leaq 0x4b1f(%rip), %r15      # 0xedd6
leaq 0x4b0d(%rip), %r13      # 0xedcb
cmpq 0xa35d3(%rip), %r14     # 0xad898
je 0xa35e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21d0
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x2320
movq %rax, %rdi
leaq 0x4acb(%rip), %rsi      # 0xedc2
callq 0x21d0
movl 0x28(%r14), %esi
movq %rax, %rdi
callq 0x2320
movq %rax, %rdi
movq %r15, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
movq 0x30(%r14), %rbp
xorl %r12d, %r12d
leaq (%r12,%rbp), %rax
cmpq 0x38(%r14), %rax
je 0xa355
movq %rbx, %rdi
movq %r13, %rsi
callq 0x21d0
movq 0x30(%r14), %rcx
movl (%rcx,%r12), %esi
movq %rax, %rdi
callq 0x2320
movq %rax, %rdi
callq 0x20f0
addq $0x4, %r12
jmp 0xa322
addq $0x50, %r14
jmp 0xa2be
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zhengwangsun[P]pas2c/semantics.cpp
// Function: showSubTable()
void showSubTable()//显示子表信息
{
    int i = 0;
    for(vector<subTableItem>::iterator it = subTable.begin(); it != subTable.end();it++)
    {
        cout<<"subTable:";
        cout<<it->name<<endl;
        cout<<"        "<<"item:"<<endl;
        for(vector<Tuple>::iterator it1 = it->item.begin(); it1 != it->item.end();it1++)
        {
            cout<<"        "<<it1->name<<"   "<<it1->type<<"   line:"<<it1->declareRow<<"   "<<endl;
            for (vector<int>::iterator it3 = it1->useRow.begin(); it3 != it1->useRow.end();it3++)
            {
                cout<<"              "<<it1->useRow[i]<<endl;
                i++;
            }
        }
        cout<<"        "<<"argument:"<<endl;
        for(vector<Tuple>::iterator it2 = it->argument.begin(); it2 != it->argument.end();it2++)
        {
            cout<<"        "<<it2->name<<"   "<<it2->type<<endl;

        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r14d, %r14d
movq 0xa3526(%rip), %r15     # 0xad8a8
movq 0x9c47(%rip), %rbx      # 0x13fd0
leaq 0x4a3b(%rip), %r12      # 0xedcb
cmpq 0xa3519(%rip), %r15     # 0xad8b0
je 0xa508
movq %rbx, %rdi
leaq 0x4a33(%rip), %rsi      # 0xedda
callq 0x21d0
leaq 0x30(%r15), %rsi
movq %rbx, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20f0
movq %rbx, %rdi
leaq 0x4a07(%rip), %rsi      # 0xedd1
callq 0x21d0
movq %rax, %rdi
leaq 0x4a0b(%rip), %rsi      # 0xede4
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
movq (%r15), %r13
movq 0x8(%r15), %rbp
movq %rbx, %rdi
leaq 0x49da(%rip), %rsi      # 0xedd1
callq 0x21d0
movq %rax, %rdi
cmpq %rbp, %r13
je 0xa49e
movq %r13, %rsi
callq 0x21c0
movq %rax, %rdi
leaq 0x49bc(%rip), %rbp      # 0xedd6
movq %rbp, %rsi
callq 0x21d0
movl 0x20(%r13), %esi
movq %rax, %rdi
callq 0x2320
movq %rax, %rdi
leaq 0x498a(%rip), %rsi      # 0xedc2
callq 0x21d0
movl 0x28(%r13), %esi
movq %rax, %rdi
callq 0x2320
movq %rax, %rdi
movq %rbp, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
movq 0x30(%r13), %rbp
movslq %r14d, %r14
cmpq 0x38(%r13), %rbp
je 0xa495
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21d0
movq 0x30(%r13), %rcx
movl (%rcx,%r14,4), %esi
movq %rax, %rdi
callq 0x2320
movq %rax, %rdi
callq 0x20f0
incq %r14
addq $0x4, %rbp
jmp 0xa463
addq $0x50, %r13
jmp 0xa3e9
leaq 0x4945(%rip), %rsi      # 0xedea
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
movq 0x18(%r15), %r13
cmpq 0x20(%r15), %r13
je 0xa4ff
movq %rbx, %rdi
leaq 0x490b(%rip), %rsi      # 0xedd1
callq 0x21d0
movq %rax, %rdi
movq %r13, %rsi
callq 0x21c0
movq %rax, %rdi
leaq 0x48f6(%rip), %rsi      # 0xedd6
callq 0x21d0
movl 0x20(%r13), %esi
movq %rax, %rdi
callq 0x2320
movq %rax, %rdi
callq 0x20f0
addq $0x50, %r13
jmp 0xa4b6
addq $0x60, %r15
jmp 0xa390
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/zhengwangsun[P]pas2c/grammar.cpp
// Function: GetFollow()
void GetFollow()                       //求所有非终结符的FOLLOW集的函数
{
	int i=0;
	bool Follow[VNnum]={false};        //判断某一非终结符的 FOLLOW 集是否已求的数组 
	for(i=0;i<VNnum;i++)
	{
		GetFollowGroup(i,Follow);
		Follow[i]=true;
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
andq $0x0, 0x1f(%rbx)
xorl %r14d, %r14d
cmpq $0x27, %r14
je 0xb678
movl %r14d, %edi
movq %rbx, %rsi
callq 0xc84f
movb $0x1, (%rsp,%r14)
incq %r14
jmp 0xb65d
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/zhengwangsun[P]pas2c/grammar.cpp
// Function: CreatAnalysisTable()
void CreatAnalysisTable(void)          //LL(1)分析表的创建函数
{
	int i,j,k,m,n;
	//初始化 
	for(i=0;i<VNnum;i++)
		for(j=0;j<VTnum+1;j++)
			AnalysisTable[i][j]=-1;
	
	for(i=0;i<GenerationNum;i++)
	{
		for(j=0;g[i].FIRST[j]!=-1;j++)
		{
			m=g[i].left;
			n=g[i].FIRST[j]-100;
			AnalysisTable[m][n]=i;
		}
		if(e_belongstoF(i))
		{
			for(j=0;g[i].FOLLOW[j]!=-1;j++)
			{
				m=g[i].left;
				n=g[i].FOLLOW[j]-100;
				AnalysisTable[m][n]=i;
			}	
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xa701e(%rip), %rax     # 0xb26b0
xorl %ecx, %ecx
cmpq $0x27, %rcx
je 0xb6b6
xorl %edx, %edx
cmpq $0x2a, %rdx
je 0xb6ab
orl $-0x1, (%rax,%rdx,4)
incq %rdx
jmp 0xb69c
incq %rcx
addq $0xa8, %rax
jmp 0xb694
leaq 0xa3213(%rip), %r14     # 0xae8d0
leaq 0xa325c(%rip), %r15     # 0xae920
xorl %ebx, %ebx
leaq 0xa6fe3(%rip), %r13     # 0xb26b0
movl $0xd0, %ebp
cmpq $0x4c, %rbx
je 0xb74f
imulq $0xd0, %rbx, %r12
leaq 0xa31ba(%rip), %rax     # 0xae8a0
addq %rax, %r12
movq %r14, %rax
movslq (%rax), %rcx
cmpq $-0x1, %rcx
je 0xb711
movslq 0x4(%r12), %rdx
imulq $0xa8, %rdx, %rdx
addq %r13, %rdx
movl %ebx, -0x190(%rdx,%rcx,4)
addq $0x4, %rax
jmp 0xb6ec
movl %ebx, %edi
callq 0xc4c3
testb %al, %al
je 0xb744
movq %r15, %rax
movslq (%rax), %rcx
cmpq $-0x1, %rcx
je 0xb744
movslq 0x4(%r12), %rdx
imulq $0xa8, %rdx, %rdx
addq %r13, %rdx
movl %ebx, -0x190(%rdx,%rcx,4)
addq $0x4, %rax
jmp 0xb71f
incq %rbx
addq %rbp, %r14
addq %rbp, %r15
jmp 0xb6d2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zhengwangsun[P]pas2c/grammar.cpp
// Function: initTree()
void initTree()
{
	tree.size=0;
    tree.node[0].type=0;
	tree.node[0].code="Program";
	for(int i=0;i<999;i++)
	{
		tree.node[i].childNum=0;
		tree.node[i].isT=false;
		tree.node[i].code="";
		tree.node[i].row=-1;
		tree.node[i].numType=-1;
		tree.node[i].value="";
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
andl $0x0, 0xa7ff7(%rip)     # 0xb4098
andl $0x0, 0xa804c(%rip)     # 0xb40f4
leaq 0xa8051(%rip), %rbx     # 0xb4100
leaq 0x2f7a(%rip), %rsi      # 0xf030
movq %rbx, %rdi
callq 0x2360
movl $0x3e7, %r15d           # imm = 0x3E7
leaq 0x22d9(%rip), %r14      # 0xe3a4
subq $0x1, %r15
jb 0xc0fe
andl $0x0, -0x60(%rbx)
movb $0x0, -0x8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2360
orq $-0x1, 0x40(%rbx)
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x2360
addq $0xa8, %rbx
jmp 0xc0cb
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/zhengwangsun[P]pas2c/grammar.cpp
// Function: DFS(int)
int DFS(int v)
{
	//若当前节点没有儿子节点 
	if(tree.node[v].childNum==0) 
	{
		if(tree.node[v].isT)  //当前节点是终结符，则没有找到 
		    return -1;
		else
		    return v; 
	}
	else //非终结符，有儿子节点 
	{
		for(int i=0;i<tree.node[v].childNum;i++)
		{
			int te=DFS(tree.node[v].child[i]);
			if(te!=-1)
				return te;
		} 
	}
	return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movslq %edi, %rax
imulq $0xa8, %rax, %rax
leaq 0xa7f7b(%rip), %rcx     # 0xb4098
leaq (%rax,%rcx), %r14
addq $0x8, %r14
movl (%r14), %r15d
testl %r15d, %r15d
je 0xc155
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
pushq $-0x1
popq %rbx
cmpq %r12, %r15
je 0xc162
movl 0x4(%r14,%r12,4), %edi
callq 0xc104
incq %r12
cmpl $-0x1, %eax
je 0xc13a
movl %eax, %ebx
jmp 0xc162
movl %edi, %ebx
cmpb $0x0, 0x58(%r14)
pushq $-0x1
popq %rax
cmovnel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/zhengwangsun[P]pas2c/grammar.cpp
// Function: getVnVtString[abi:cxx11](int)
string getVnVtString(int a)
{
	for(int i=0;i<VNnum;i++)
		if(vn[i].value==a)
			return vn[i].name;
	for(int i=0;i<VTnum;i++)
		if(vt[i].value==a)
			return vt[i].name;
     return "";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x28
popq %rcx
leaq 0x2421a6(%rip), %rdx    # 0x24e328
decq %rcx
je 0xc195
leaq 0x28(%rdx), %rax
cmpl %esi, 0x48(%rdx)
movq %rax, %rdx
jne 0xc182
jmp 0xc1b0
pushq $0x2a
popq %rcx
leaq 0x2427a9(%rip), %rdx    # 0x24e948
decq %rcx
je 0xc1bd
leaq 0x28(%rdx), %rax
cmpl %esi, 0x48(%rdx)
movq %rax, %rdx
jne 0xc19f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2250
jmp 0xc1d1
leaq 0x21e0(%rip), %rsi      # 0xe3a4
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x4268
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/zhengwangsun[P]pas2c/grammar.cpp
// Function: findTthId(int)
int findTthId(int t)
{
	int countTemp=0;
	for(int i=1;i<=token_count;i++)
	   if(token[i].type==101) //id
	   {
	   	    if(countTemp==t)
	   	       return i;
	   	    else
	   	       countTemp++;
	   }
	return -1; 
}

// Assembly:
leaq 0xad3f(%rip), %rax      # 0x16f20
movslq (%rax), %rcx
leaq 0xad55(%rip), %rdx      # 0x16f40
addq $0x38, %rdx
xorl %r8d, %r8d
pushq $0x1
popq %rsi
pushq $-0x1
popq %rax
cmpq %rcx, %rsi
jg 0xc215
cmpl $0x65, (%rdx)
jne 0xc20a
cmpl %edi, %r8d
je 0xc213
incl %r8d
incq %rsi
addq $0x38, %rdx
jmp 0xc1f8
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/zhengwangsun[P]pas2c/grammar.cpp
// Function: findTthNum(int)
int findTthNum(int t)
{
	int countTemp=0;
	for(int i=1;i<=token_count;i++)
	   if(token[i].type==119)   //num
	   {
	   	    if(countTemp==t)
	   	       return i;
	   	    else
	   	       countTemp++;
	   }
	return -1;	
}

// Assembly:
leaq 0xad03(%rip), %rax      # 0x16f20
movslq (%rax), %rcx
leaq 0xad19(%rip), %rdx      # 0x16f40
addq $0x38, %rdx
xorl %r8d, %r8d
pushq $0x1
popq %rsi
pushq $-0x1
popq %rax
cmpq %rcx, %rsi
jg 0xc251
cmpl $0x77, (%rdx)
jne 0xc246
cmpl %edi, %r8d
je 0xc24f
incl %r8d
incq %rsi
addq $0x38, %rdx
jmp 0xc234
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/zhengwangsun[P]pas2c/grammar.cpp
// Function: findTthOp(int)
int findTthOp(int t)
{
	int countTemp=0;
	for(int i=1;i<=token_count;i++)
	   if(token[i].type==131 || token[i].type==133)   //mulop relop 
	   {
	   	    if(countTemp==t)
	   	       return i;
	   	    else
	   	       countTemp++;
	   }
	return -1;
}

// Assembly:
leaq 0xacc7(%rip), %rax      # 0x16f20
movslq (%rax), %rcx
leaq 0xacdd(%rip), %rdx      # 0x16f40
addq $0x38, %rdx
xorl %r8d, %r8d
pushq $0x1
popq %rsi
pushq $-0x1
popq %rax
cmpq %rcx, %rsi
jg 0xc29d
movl (%rdx), %r9d
cmpl $0x85, %r9d
je 0xc28a
cmpl $0x83, %r9d
jne 0xc292
cmpl %edi, %r8d
je 0xc29b
incl %r8d
incq %rsi
addq $0x38, %rdx
jmp 0xc270
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/zhengwangsun[P]pas2c/grammar.cpp
// Function: e_belongstoF(int)
bool e_belongstoF(int num)             //判断编号为num的生成式右部字符串的FIRST集中是否含有ε
{
	int i,flag=1;                      //为1表示不含 ε
	for(i=0;g[num].FIRST[i]!=-1&&i<FIRSTnum;i++)
	{
		if(g[num].FIRST[i]==106)
			flag=0;
	}
	if(flag==1)//不含ε
		return false;
	else
		return true;
}

// Assembly:
movslq %edi, %rax
imulq $0xd0, %rax, %rax
leaq 0xa23cc(%rip), %rcx     # 0xae8a0
addq %rax, %rcx
addq $0x30, %rcx
pushq $0x1
popq %rax
xorl %edx, %edx
xorl %esi, %esi
cmpq $0x13, %rsi
ja 0xc4fb
movl (%rcx,%rsi,4), %edi
cmpl $-0x1, %edi
je 0xc4fb
cmpl $0x6a, %edi
cmovel %edx, %eax
incq %rsi
jmp 0xc4e2
cmpl $0x1, %eax
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/app/genipaessentials/genipaessentials.cpp
// Function: loadFormulaDualRailed(void*, char const*, int*)
bool loadFormulaDualRailed(void* solver, const char* filename, int* outVariables) {
	FILE* f = fopen(filename, "r");
	if (f == NULL) {
		return false;
	}
	int maxVar = 0;
	int c = 0;
	bool neg = false;
	while (c != EOF) {
		c = fgetc(f);

		// comment or problem definition line
		if (c == 'c' || c == 'p') {
			// skip this line
			while(c != '\n') {
				c = fgetc(f);
			}
			continue;
		}
		// whitespace
		if (isspace(c)) {
			continue;
		}
		// negative
		if (c == '-') {
			neg = true;
			continue;
		}

		// number
		if (isdigit(c)) {
			int num = c - '0';
			c = fgetc(f);
			while (isdigit(c)) {
				num = num*10 + (c-'0');
				c = fgetc(f);
			}
			if (neg) {
				num *= -1;
			}
			neg = false;

			if (abs(num) > maxVar) {
				maxVar = abs(num);
			}
			// add to the solver
			ipasir_add(solver, getDualRailName(num));
		}
	}
	fclose(f);
	// add the extra clauses
	for (int var = 1; var <= maxVar; var++) {
		ipasir_add(solver, -getDualRailName(var));
		ipasir_add(solver, -getDualRailName(-var));
		ipasir_add(solver, 0);
	}
	*outVariables = maxVar;
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq 0xf8cd(%rip), %rsi      # 0x10c3b
movq %rax, %rdi
callq 0x1170
movq %rax, %r15
testq %rax, %rax
je 0x1496
movq %rbx, 0x10(%rsp)
xorl %ebp, %ebp
pushq $0xa
popq %r13
xorl %r12d, %r12d
xorl %ebx, %ebx
movl %r12d, %eax
movl %ebx, %ecx
movl %ecx, %ebx
movl %eax, %r12d
movq %r15, %rdi
cmpl $-0x1, %r12d
je 0x1457
callq 0x1200
movl %eax, %r12d
cmpl $0x70, %eax
je 0x13d5
cmpl $0x63, %r12d
je 0x13d5
movl %r12d, %edi
callq 0x1040
testl %eax, %eax
jne 0x139c
jmp 0x13e0
movq %r15, %rdi
callq 0x1200
movl %eax, %r12d
cmpl $0xa, %r12d
jne 0x13ca
movl %r13d, %r12d
jmp 0x139c
movb $0x1, %cl
pushq $0x2d
popq %rax
cmpl $0x2d, %r12d
je 0x1397
movl %r12d, %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x1392
movl %eax, 0xc(%rsp)
movq %r15, %rdi
callq 0x1200
movl %eax, %r12d
leal -0x30(%r12), %eax
cmpl $0x9, %eax
ja 0x141e
movl 0xc(%rsp), %ecx
imull $0xa, %ecx, %ecx
addl %eax, %ecx
movl %ecx, 0xc(%rsp)
jmp 0x13fa
movl 0xc(%rsp), %edx
movl %edx, %eax
negl %eax
movl %edx, %ecx
cmovnsl %eax, %ecx
testb $0x1, %bl
cmovel %edx, %eax
xorl %esi, %esi
testl %eax, %eax
setle %sil
leal (%rax,%rax), %edx
negl %esi
xorl %edx, %esi
testl %eax, %eax
cmovel %eax, %esi
cmpl %ebp, %ecx
cmovgl %ecx, %ebp
movq %r14, %rdi
callq 0x1957
jmp 0x1390
callq 0x1110
pushq $-0x1
popq %r12
movl %ebp, %ebx
subl $0x1, %ebx
jb 0x148f
leal -0x1(%r12), %esi
movq %r14, %rdi
callq 0x1957
movq %r14, %rdi
movl %r12d, %esi
callq 0x1957
movq %r14, %rdi
xorl %esi, %esi
callq 0x1957
addl $-0x2, %r12d
jmp 0x1462
movq 0x10(%rsp), %rax
movl %ebp, (%rax)
testq %r15, %r15
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/app/genipaessentials/genipaessentials.cpp
// Function: learnCb(void*, int*)
void learnCb(void* state, int* clause) {
	if (clause[0] == 0) ;
	else if (clause[1] == 0) lunits++;
	else if (clause[2] == 0) lbins++;
	else if (clause[3] == 0) lterns++;
}

// Assembly:
cmpl $0x0, (%rsi)
je 0x14c2
cmpl $0x0, 0x4(%rsi)
je 0x14c3
cmpl $0x0, 0x8(%rsi)
je 0x14cc
cmpl $0x0, 0xc(%rsi)
je 0x14d5
retq
leaq 0x13c72(%rip), %rax     # 0x1513c
jmp 0x14dc
leaq 0x13c6d(%rip), %rax     # 0x15140
jmp 0x14dc
leaq 0x13c68(%rip), %rax     # 0x15144
incl (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/kaityo256[P]lj_simd/force_soa.cpp
// Function: force_pair()
void
force_pair(void) {
  for (int k = 0; k < number_of_pairs; k++) {
    const int i = i_particles[k];
    const int j = j_particles[k];
    double dx = q[X][j] - q[X][i];
    double dy = q[Y][j] - q[Y][i];
    double dz = q[Z][j] - q[Z][i];
    double r2 = (dx * dx + dy * dy + dz * dz);
    //if (r2 > CL2) continue;
    double r6 = r2 * r2 * r2;
    double df = ((24.0 * r6 - 48.0) / (r6 * r6 * r2)) * dt;
    if (r2 > CL2) df = 0.0;
    p[X][i] += df * dx;
    p[Y][i] += df * dy;
    p[Z][i] += df * dz;
    p[X][j] -= df * dx;
    p[Y][j] -= df * dy;
    p[Z][j] -= df * dz;
  }
}

// Assembly:
vmovsd 0x25aa(%rip), %xmm0     # 0x4028
vmovsd 0x25aa(%rip), %xmm1     # 0x4030
vmovsd 0x25aa(%rip), %xmm2     # 0x4038
vmovsd 0x25aa(%rip), %xmm3     # 0x4040
movslq 0x19f5077(%rip), %rax   # 0x19f6b14
leaq 0x1b7ba7c(%rip), %rdx   # 0x1b7d520
leaq 0x4942675(%rip), %rsi   # 0x4944120
leaq 0x18b05e(%rip), %rdi    # 0x18cb10
vxorpd %xmm4, %xmm4, %xmm4
leaq 0xdc0053(%rip), %r8     # 0xdc1b10
xorl %ecx, %ecx
xorl %r9d, %r9d
cmpq %rax, %r9
jge 0x1bcb
movslq (%rcx,%rsi), %r10
movslq (%rcx,%rdx), %r11
vmovapd %xmm0, %xmm10
incq %r9
addq $0x4, %rcx
vmovsd 0x30d400(%rdi,%r10,8), %xmm6
vmovsd (%rdi,%r10,8), %xmm5
vmovsd 0x61a800(%rdi,%r10,8), %xmm7
vsubsd 0x30d400(%rdi,%r11,8), %xmm6, %xmm6
vsubsd (%rdi,%r11,8), %xmm5, %xmm5
vsubsd 0x61a800(%rdi,%r11,8), %xmm7, %xmm7
vmulsd %xmm6, %xmm6, %xmm8
vfmadd231sd %xmm5, %xmm5, %xmm8 # xmm8 = (xmm5 * xmm5) + xmm8
vfmadd231sd %xmm7, %xmm7, %xmm8 # xmm8 = (xmm7 * xmm7) + xmm8
vmulsd %xmm8, %xmm8, %xmm9
vcmpgtsd %xmm3, %xmm8, %k1
vmulsd %xmm9, %xmm8, %xmm9
vfmadd213sd %xmm1, %xmm9, %xmm10 # xmm10 = (xmm9 * xmm10) + xmm1
vmulsd %xmm9, %xmm9, %xmm9
vmulsd %xmm9, %xmm8, %xmm9
vmovsd (%r8,%r11,8), %xmm8
vdivsd %xmm9, %xmm10, %xmm9
vmulsd %xmm2, %xmm9, %xmm9
vmovsd %xmm4, %xmm9, %xmm9 {%k1}
vfmadd231sd %xmm5, %xmm9, %xmm8 # xmm8 = (xmm9 * xmm5) + xmm8
vmovsd %xmm8, (%r8,%r11,8)
vmovsd 0x30d400(%r8,%r11,8), %xmm8
vfmadd231sd %xmm6, %xmm9, %xmm8 # xmm8 = (xmm9 * xmm6) + xmm8
vmovsd %xmm8, 0x30d400(%r8,%r11,8)
vmovsd 0x61a800(%r8,%r11,8), %xmm8
vfmadd231sd %xmm7, %xmm9, %xmm8 # xmm8 = (xmm9 * xmm7) + xmm8
vmovsd %xmm8, 0x61a800(%r8,%r11,8)
vfnmadd213sd (%r8,%r10,8), %xmm9, %xmm5 # xmm5 = -(xmm9 * xmm5) + mem
vmovsd %xmm5, (%r8,%r10,8)
vfnmadd213sd 0x30d400(%r8,%r10,8), %xmm9, %xmm6 # xmm6 = -(xmm9 * xmm6) + mem
vmovsd %xmm6, 0x30d400(%r8,%r10,8)
vfnmadd213sd 0x61a800(%r8,%r10,8), %xmm9, %xmm7 # xmm7 = -(xmm9 * xmm7) + mem
vmovsd %xmm7, 0x61a800(%r8,%r10,8)
jmp 0x1ac2
retq
// File: /workspace/github_cpp_makefile_star2_O2/kaityo256[P]lj_simd/force_soa.cpp
// Function: main
int
main(void) {
  SoADataManager soadm(p, q);
  init(&soadm, particle_number);
  check_pairlist(particle_number, number_of_pairs, number_of_partners, i_particles, j_particles, &soadm);
  sortpair(particle_number, number_of_pairs, number_of_partners, i_particles, j_particles, pointer, sorted_list);
#ifdef PAIR
  measure(&force_pair, "SoA+Pair", particle_number);
  soadm.print_results(particle_number);
#elif SORTED
  measure(&force_sorted, "SoA+Sorted", particle_number);
  soadm.print_results(particle_number);
#elif SORTED_SWP
  measure(&force_sorted_swp, "SoA+Sorted+SWP", particle_number);
  soadm.print_results(particle_number);
#elif AVX2
  measure(&force_avx2, "SoA+Sorted+AVX2", particle_number);
  soadm.print_results(particle_number);
#elif AVX2_SWP
  measure(&force_avx2_swp, "SoA+Sorted+AVX2+SWP", particle_number);
  soadm.print_results(particle_number);
#elif AVX512_SIMPLE
  measure(&force_avx512, "SoA+AVX-512+CDE", particle_number);
  soadm.print_results(particle_number);
#elif AVX512_LOOPOPT
  measure(&force_avx512_loopopt, "SoA+AVX-512+CDE+RLE", particle_number);
  soadm.print_results(particle_number);
#elif AVX512_LOOPOPT_SWP
  measure(&force_avx512_loopopt_swp, "SoA+AVX-512+CDE+RLE+SWP", particle_number);
  soadm.print_results(particle_number);
#else
  measure(&force_pair, "SoA+Pair", particle_number);
  measure(&force_sorted, "SoA+Sorted", particle_number);
  measure(&force_sorted_swp, "SoA+Sorted+SWP", particle_number);
  measure(&force_avx2, "SoA+Sorted+AVX2", particle_number);
  measure(&force_avx2_swp, "SoA+Sorted+AVX2+SWP", particle_number);
#ifdef AVX512
  measure(&force_avx512, "SoA+AVX-512+CDE", particle_number);
  measure(&force_avx512_loopopt, "SoA+AVX-512+CDE+RLE", particle_number);
  measure(&force_avx512_loopopt_swp, "SoA+AVX-512+CDE+RLE+SWP", particle_number);
#endif //AVX512
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
leaq 0x3181(%rip), %rax      # 0x5d78
leaq 0xdbef12(%rip), %rdx    # 0xdc1b10
leaq 0x189f0b(%rip), %rcx    # 0x18cb10
leaq 0x19f3f04(%rip), %rsi   # 0x19f6b10
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movq %rbx, %rdi
movq %rcx, 0x10(%rbx)
callq 0x18d8
movl 0x19f3eeb(%rip), %edi   # 0x19f6b10
leaq 0x19f3ee8(%rip), %r14   # 0x19f6b14
leaq 0x19f3eed(%rip), %r15   # 0x19f6b20
leaq 0x1b7a8e6(%rip), %r12   # 0x1b7d520
leaq 0x49414df(%rip), %r13   # 0x4944120
movq %rbx, %r9
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x176c
movl 0x19f3eb5(%rip), %edi   # 0x19f6b10
leaq 0x7a154be(%rip), %rax   # 0x7a18120
leaq 0x77080b7(%rip), %r9    # 0x770ad20
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
movq %rax, (%rsp)
callq 0x1841
movl 0x19f3e8c(%rip), %edx   # 0x19f6b10
leaq -0x2ea(%rip), %rdi      # 0x29a1
leaq 0x1464(%rip), %rsi      # 0x40f6
callq 0x14d9
movl 0x19f3e73(%rip), %esi   # 0x19f6b10
movq %rbx, %rdi
callq 0x2cb6
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kaityo256[P]lj_simd/force_soa.cpp
// Function: SoADataManager::print_results(int)
void
    print_results(int particle_number) {
      for (int i = 0; i < 5; i++) {
        printf("%.10f %.10f %.10f\n", p[X][i], p[Y][i], p[Z][i]);
      }
      for (int i = particle_number - 5; i < particle_number; i++) {
        printf("%.10f %.10f %.10f\n", p[X][i], p[Y][i], p[Z][i]);
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x13ad(%rip), %r15      # 0x4072
movl %esi, %r14d
movq %rdi, %rbx
xorl %r12d, %r12d
cmpq $0x5, %r12
je 0x2d01
movq 0x8(%rbx), %rax
movq %r15, %rdi
vmovsd (%rax,%r12,8), %xmm0
vmovsd 0x30d400(%rax,%r12,8), %xmm1
vmovsd 0x61a800(%rax,%r12,8), %xmm2
movb $0x3, %al
callq 0x1030
incq %r12
jmp 0x2cce
leal -0x5(%r14), %eax
movslq %r14d, %r12
leaq 0x1363(%rip), %r14      # 0x4072
movslq %eax, %r15
cmpq %r12, %r15
jge 0x2d44
movq 0x8(%rbx), %rax
movq %r14, %rdi
vmovsd (%rax,%r15,8), %xmm0
vmovsd 0x30d400(%rax,%r15,8), %xmm1
vmovsd 0x61a800(%rax,%r15,8), %xmm2
movb $0x3, %al
callq 0x1030
incq %r15
jmp 0x2d12
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/kaityo256[P]lj_simd/force_soa.cpp
// Function: SoADataManager::add_particle(double, double, double, int&)
void
    add_particle(double x, double y, double z, int &particle_number) {
      static std::mt19937 mt(2);
      std::uniform_real_distribution<double> ud(0.0, 0.1);
      q[X][particle_number] = x + ud(mt);
      q[Y][particle_number] = y + ud(mt);
      q[Z][particle_number] = z + ud(mt);
      particle_number++;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
vmovsd %xmm2, 0x18(%rsp)
vmovsd %xmm1, 0x10(%rsp)
vmovsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movb 0xa7dd32f(%rip), %al    # 0xa7e00a8
testb %al, %al
je 0x2e0d
vxorpd %xmm0, %xmm0, %xmm0
vmovhpd 0x12cb(%rip), %xmm0, %xmm0 # xmm0 = xmm0[0],mem[0]
leaq 0x20(%rsp), %r15
leaq 0xa7dbf87(%rip), %r12   # 0xa7ded20
movq %r15, %rdi
movq %r12, %rsi
vmovapd %xmm0, (%r15)
callq 0x2ea0
vaddsd 0x8(%rsp), %xmm0, %xmm0
movq 0x10(%r14), %rax
movslq (%rbx), %rcx
movq %r15, %rdi
movq %r12, %rsi
vmovsd %xmm0, (%rax,%rcx,8)
callq 0x2ea0
vaddsd 0x10(%rsp), %xmm0, %xmm0
movq 0x10(%r14), %rax
movslq (%rbx), %rcx
movq %r15, %rdi
movq %r12, %rsi
vmovsd %xmm0, 0x30d400(%rax,%rcx,8)
callq 0x2ea0
vaddsd 0x18(%rsp), %xmm0, %xmm0
movq 0x10(%r14), %rax
movslq (%rbx), %rcx
vmovsd %xmm0, 0x61a800(%rax,%rcx,8)
incl %ecx
movl %ecx, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xa7dd294(%rip), %rdi   # 0xa7e00a8
callq 0x1170
testl %eax, %eax
je 0x2d81
leaq 0xa7dbef8(%rip), %rdi   # 0xa7ded20
pushq $0x2
popq %rsi
callq 0x2ea8
leaq 0xa7dd271(%rip), %rdi   # 0xa7e00a8
callq 0x1090
jmp 0x2d81
leaq 0xa7dd260(%rip), %rdi   # 0xa7e00a8
movq %rax, %rbx
callq 0x1080
movq %rbx, %rdi
callq 0x1160