LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseFunction::get_info[abi:cxx11]() const
string ParseFunction::get_info() const {
    string res = "ParseFunction { return_type:" + ret_type.get_info() +
                 ", symbol:" + symbol + ", args[";
    for (const auto &each : args) {
        res += each.get_info() + ", ";
    }
    res += "], address:";
    char buff[32];
    sprintf(buff, "%zu }", address);
    return res + buff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, -0x38(%rbp)
leaq -0xe0(%rbp), %rbx
movq %rbx, %rdi
movq %rsi, -0x30(%rbp)
callq 0x215a0
leaq 0x14044(%rip), %rsi     # 0x3b79c
leaq -0xc0(%rbp), %rdi
movq %rbx, %rdx
callq 0xc837
leaq 0x14018(%rip), %rdx     # 0x3b786
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0xc8d6
movq -0x30(%rbp), %rax
leaq 0x38(%rax), %rdx
leaq -0x60(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xd418
leaq 0x14019(%rip), %rdx     # 0x3b7b9
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xc8d6
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x4598
leaq -0xa0(%rbp), %r12
movq %r12, %rdi
callq 0x4598
leaq -0xc0(%rbp), %rdi
callq 0x4598
leaq -0xe0(%rbp), %rdi
callq 0x4598
movq -0x30(%rbp), %rax
movq 0x58(%rax), %r13
movq 0x60(%rax), %rbx
leaq -0x80(%rbp), %r14
cmpq %rbx, %r13
je 0x27833
movq %r12, %rdi
movq %r13, %rsi
callq 0x273ac
movq %r15, %rdi
movq %r12, %rsi
leaq 0x13287(%rip), %rdx     # 0x3aa94
callq 0xc8d6
movq %r14, %rdi
movq %r15, %rsi
callq 0x4580
movq %r15, %rdi
callq 0x4598
movq %r12, %rdi
callq 0x4598
addq $0x68, %r13
jmp 0x277f0
leaq 0x13f87(%rip), %rsi     # 0x3b7c1
leaq -0x80(%rbp), %rdi
callq 0x4540
movq -0x30(%rbp), %rax
movq 0x70(%rax), %rdx
leaq 0x139de(%rip), %rsi     # 0x3b230
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x40b0
leaq -0x80(%rbp), %rsi
movq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0xca9e
leaq -0x80(%rbp), %rdi
callq 0x4598
movq %r14, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x278d1
jmp 0x278d1
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x4598
jmp 0x278a6
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x4598
jmp 0x278b7
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x4598
jmp 0x278c8
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
jmp 0x278f7
movq %rax, %rbx
jmp 0x278f3
movq %rax, %rbx
jmp 0x278e7
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x4598
leaq -0xa0(%rbp), %rdi
callq 0x4598
leaq -0x80(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::assign(ParseConstant&, ParseConstant const&)
void ParseConstant::assign(ParseConstant &constant, const ParseConstant &from_constant) {
    constant.type = from_constant.type;
    switch (constant.type) {
        case C_STRING:
            constant.value = (size_t) new string(*(string *) from_constant.value);
            break;
        case C_SIGNED:
            constant.value = (size_t) new long long(*(long long *) from_constant.value);
            break;
        case C_UNSIGNED:
            constant.value = (size_t) new unsigned long long(*(unsigned long long *) from_constant.value);
            break;
        case C_FLOAT:
            constant.value = (size_t) new long double(*(long double *) from_constant.value);
            break;
        case C_BOOL:
            constant.value = (size_t) new bool(*(bool *) from_constant.value);
            break;
        case C_UNDEFINED:
            constant.value = 0;
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl (%rsi), %eax
movl %eax, (%rdi)
cmpq $0x5, %rax
ja 0x27a05
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x13cd3(%rip), %rcx     # 0x3b66c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x8
popq %rdi
callq 0x42a0
movq %rax, %r15
movq 0x8(%r14), %rax
movq (%rax), %rax
movq %rax, (%r15)
jmp 0x27a01
pushq $0x1
popq %rdi
callq 0x42a0
movq %rax, %r15
movq 0x8(%r14), %rax
movb (%rax), %al
movb %al, (%r15)
jmp 0x27a01
pushq $0x20
popq %rdi
callq 0x42a0
movq %rax, %r15
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x43a0
jmp 0x27a01
pushq $0x10
popq %rdi
callq 0x42a0
movq %rax, %r15
movq 0x8(%r14), %rax
fldt (%rax)
fstpt (%r15)
jmp 0x27a01
xorl %r15d, %r15d
movq %r15, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x4270
movq %rbx, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_signed() const
long long ParseConstant::get_signed() const {
    switch (type) {
        case C_SIGNED:
            return *(long long *) value;
        case C_UNSIGNED:
            return *(unsigned long long *) value;
        case C_FLOAT:
            return (long long) *(long double *) value;
        case C_BOOL:
            return (long long) *(bool *) value;
        case C_STRING:
        case C_UNDEFINED:
            break;
    }
    printf("ParseConstant::get_signed(): 警告 : 试图获取非法常量值\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x27b6e
leaq 0x13b56(%rip), %rcx     # 0x3b684
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
movq (%rax), %rax
jmp 0x27b7c
movq 0x8(%rdi), %rax
fldt (%rax)
fnstcw -0x2(%rbp)
movzwl -0x2(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x4(%rbp)
fldcw -0x4(%rbp)
fistpll -0x10(%rbp)
fldcw -0x2(%rbp)
movq -0x10(%rbp), %rax
jmp 0x27b7c
movq 0x8(%rdi), %rax
movzbl (%rax), %eax
jmp 0x27b7c
leaq 0x14233(%rip), %rdi     # 0x3bda8
callq 0x4430
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_unsigned() const
unsigned long long ParseConstant::get_unsigned() const {
    switch (type) {
        case C_SIGNED:
            return (unsigned long long) *(long long *) value;
        case C_UNSIGNED:
            return *(unsigned long long *) value;
        case C_FLOAT:
            return (unsigned long long) *(long double *) value;
        case C_BOOL:
            return (unsigned long long) *(bool *) value;
        case C_STRING:
        case C_UNDEFINED:
            break;
    }
    printf("ParseConstant::get_unsigned(): 警告 : 试图获取非法常量值\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x27bf4
leaq 0x13afa(%rip), %rcx     # 0x3b694
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
movq (%rax), %rax
jmp 0x27c02
movq 0x8(%rdi), %rax
fldt (%rax)
flds 0x13ba8(%rip)           # 0x3b760
xorl %eax, %eax
fucomi %st(1), %st
setbe %al
fldz
fcmovbe %st(1), %st
fstp %st(1)
fsubrp %st, %st(1)
fnstcw -0x2(%rbp)
movzwl -0x2(%rbp), %ecx
orl $0xc00, %ecx            # imm = 0xC00
movw %cx, -0x4(%rbp)
fldcw -0x4(%rbp)
fistpll -0x10(%rbp)
fldcw -0x2(%rbp)
shlq $0x3f, %rax
xorq -0x10(%rbp), %rax
jmp 0x27c02
movq 0x8(%rdi), %rax
movzbl (%rax), %eax
jmp 0x27c02
leaq 0x141ef(%rip), %rdi     # 0x3bdea
callq 0x4430
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_float() const
long double ParseConstant::get_float() const {
    switch (type) {
        case C_SIGNED:
            return *(long long *) value;
        case C_UNSIGNED:
            return *(unsigned long long *) value;
        case C_FLOAT:
            return *(long double *) value;
        case C_BOOL:
            return (long double) *(bool *) value;
        case C_STRING:
        case C_UNDEFINED:
            break;
    }
    printf("ParseConstant::get_float(): 警告 : 试图获取非法常量值\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x27c73
leaq 0x13a84(%rip), %rcx     # 0x3b6a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
fildll -0x10(%rbp)
jmp 0x27c81
movq 0x8(%rdi), %rax
fldt (%rax)
jmp 0x27c81
movq 0x8(%rdi), %rax
movsbl (%rax), %eax
movw %ax, -0x2(%rbp)
filds -0x2(%rbp)
jmp 0x27c81
movq 0x8(%rdi), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
xorl %ecx, %ecx
testq %rax, %rax
sets %cl
fildll -0x18(%rbp)
leaq 0x13afa(%rip), %rax     # 0x3b768
fadds (%rax,%rcx,4)
jmp 0x27c81
leaq 0x141b4(%rip), %rdi     # 0x3be2e
callq 0x4430
fldz
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_bool() const
bool ParseConstant::get_bool() const {
    switch (type) {
        case C_SIGNED:
            return (bool) *(long long *) value;
        case C_UNSIGNED:
            return (bool) *(unsigned long long *) value;
        case C_FLOAT:
            return (bool) *(long double *) value;
        case C_BOOL:
            return *(bool *) value;
        case C_STRING:
        case C_UNDEFINED:
            break;
    }
    printf("ParseConstant::get_bool(): 警告 : 试图获取非法常量值\n");
    return false;
}

// Assembly:
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x27cc9
leaq 0x13a1c(%rip), %rcx     # 0x3b6b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
cmpq $0x0, (%rax)
setne %al
retq
movq 0x8(%rdi), %rax
fldt (%rax)
fldz
fucompi %st(1), %st
fstp %st(0)
setp %cl
setne %al
orb %cl, %al
retq
movq 0x8(%rdi), %rax
movb (%rax), %al
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1419b(%rip), %rdi     # 0x3be6f
callq 0x4430
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_string[abi:cxx11]() const
string ParseConstant::get_string() const {
    if (type != C_STRING) {
        printf("ParseConstant::get_string(): 警告 : 试图获取非法常量值\n");
        return "";
    }
    return *(string *) value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rsi)
je 0x27d0d
leaq 0x141bc(%rip), %rdi     # 0x3beaf
callq 0x4430
leaq 0x14a23(%rip), %rsi     # 0x3c722
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x4130
jmp 0x27d19
movq 0x8(%rsi), %rsi
movq %rbx, %rdi
callq 0x43a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_const_type_name[abi:cxx11](ConstValueType)
string ParseConstant::get_const_type_name(ConstValueType _type) {
    switch (_type) {
        case C_STRING:
            return "const_string";
        case C_SIGNED:
            return "const_signed_int";
        case C_UNSIGNED:
            return "const_unsigned_int";
        case C_FLOAT:
            return "const_float";
        case C_BOOL:
            return "const_bool";
        case C_UNDEFINED:
            break;
    }
    return "undefined";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x4, %esi
ja 0x27dc9
movl %esi, %eax
leaq 0x13959(%rip), %rcx     # 0x3b6d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x13a3e(%rip), %rsi     # 0x3b7cd
leaq -0xe(%rbp), %rdx
jmp 0x27dd4
leaq 0x13a6e(%rip), %rsi     # 0x3b80a
leaq -0xa(%rbp), %rdx
jmp 0x27dd4
leaq 0x13a42(%rip), %rsi     # 0x3b7eb
leaq -0xc(%rbp), %rdx
jmp 0x27dd4
leaq 0x13a48(%rip), %rsi     # 0x3b7fe
leaq -0xb(%rbp), %rdx
jmp 0x27dd4
leaq 0x13a17(%rip), %rsi     # 0x3b7da
leaq -0xd(%rbp), %rdx
jmp 0x27dd4
leaq 0x134c0(%rip), %rsi     # 0x3b290
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x4130
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_info[abi:cxx11]() const
string ParseConstant::get_info() const {
    char buff[64];
    switch (type) {
        case C_STRING:
            return "const string: " + *((string *) value);
        case C_SIGNED: {
            sprintf(buff, "const signed: %lld", *(long long *) value);
            return string(buff);
        }
        case C_UNSIGNED: {
            sprintf(buff, "const unsigned: %llu", *(unsigned long long *) value);
            return string(buff);
        }
        case C_FLOAT: {
            sprintf(buff, "const float: %.6Le", *(long double *) value);
            return string(buff);
        }
        case C_BOOL: {
            sprintf(buff, "const bool: %s", (*(bool *) value) ? "true" : "false");
            return string(buff);
        }
        case C_UNDEFINED: {
            return "undefined";
        }
    }
    return "unknown";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x5, %rax
ja 0x27eab
leaq 0x138e5(%rip), %rcx     # 0x3b6ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdx
leaq 0x139fa(%rip), %rsi     # 0x3b815
movq %rbx, %rdi
callq 0xcad6
jmp 0x27ebe
movq 0x8(%rsi), %rax
leaq 0x12ca2(%rip), %rcx     # 0x3aad5
leaq 0x12ca0(%rip), %rdx     # 0x3aada
cmpb $0x0, (%rax)
cmovneq %rcx, %rdx
leaq 0x13a17(%rip), %rsi     # 0x3b85f
jmp 0x27e88
movq 0x8(%rsi), %rax
movq (%rax), %rdx
leaq 0x139df(%rip), %rsi     # 0x3b837
jmp 0x27e88
movq 0x8(%rsi), %rax
fldt (%rax)
fstpt (%rsp)
leaq 0x139e2(%rip), %rsi     # 0x3b84c
leaq -0x60(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x40b0
jmp 0x27e96
movq 0x8(%rsi), %rax
movq (%rax), %rdx
leaq 0x1399c(%rip), %rsi     # 0x3b824
leaq -0x60(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x40b0
leaq -0x11(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x27eb9
leaq 0x133e7(%rip), %rsi     # 0x3b290
jmp 0x27eb2
leaq 0x12761(%rip), %rsi     # 0x3a613
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x4130
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::wider_const_type(ConstValueType, ConstValueType)
ConstValueType ParseConstant::wider_const_type(ConstValueType type1, ConstValueType type2) {
    switch (type1) {
        case C_BOOL:
        case C_STRING:
        case C_UNDEFINED:
            if (type1 == type2) {
                return type1;
            }
            break;
        case C_SIGNED: {
            switch (type2) {
                case C_SIGNED:
                    return C_SIGNED;
                case C_UNSIGNED:
                    return C_UNSIGNED;
                case C_FLOAT:
                    return C_FLOAT;
                case C_STRING:
                case C_BOOL:
                case C_UNDEFINED:
                    break;
            }
            break;
        }
        case C_UNSIGNED: {
            switch (type2) {
                case C_SIGNED:
                case C_UNSIGNED:
                    return C_UNSIGNED;
                case C_FLOAT:
                    return C_FLOAT;
                case C_STRING:
                case C_BOOL:
                case C_UNDEFINED:
                    break;
            }
            break;
        }
        case C_FLOAT: {
            switch (type2) {
                case C_SIGNED:
                case C_UNSIGNED:
                case C_FLOAT:
                    return C_FLOAT;
                case C_STRING:
                case C_BOOL:
                case C_UNDEFINED:
                    break;
            }
            break;
        }
    }
    printf("ParseConstant::wider_const_type(ConstValueType type1, ConstValueType type2):"
           "警告:常量类型%s 与 %s无法进行运算\n", get_const_type_name(type1).c_str(),
           get_const_type_name(type2).c_str());
    return C_UNDEFINED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movl %edi, %esi
cmpl $0x5, %edi
ja 0x2801c
movl %esi, %eax
leaq 0x13739(%rip), %rcx     # 0x3b718
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl %ebx, %esi
jne 0x2801c
movl %esi, %ebx
jmp 0x28062
leal -0x1(%rbx), %eax
cmpl $0x3, %eax
jb 0x28062
jmp 0x2801c
leal -0x1(%rbx), %eax
cmpl $0x3, %eax
jae 0x2801c
pushq $0x3
jmp 0x28061
leal -0x1(%rbx), %eax
cmpl $0x3, %eax
jae 0x2801c
movl %eax, %eax
leaq 0x1373d(%rip), %rcx     # 0x3b754
movl (%rcx,%rax,4), %ebx
jmp 0x28062
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x27d68
movq (%r14), %r14
leaq -0x50(%rbp), %rdi
movl %ebx, %esi
callq 0x27d68
leaq -0x50(%rbp), %rbx
movq (%rbx), %rdx
leaq 0x1382a(%rip), %rdi     # 0x3b86e
movq %r14, %rsi
xorl %eax, %eax
callq 0x4060
movq %rbx, %rdi
callq 0x4598
leaq -0x30(%rbp), %rdi
callq 0x4598
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::get_symbol_dec_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
DeclarationType ParseScope::get_symbol_dec_type(const string &symbol) const {
    auto it = symbol2dec_ptr.find(symbol);
    if (it == symbol2dec_ptr.end()) {
        if (parent_scope == this_scope) {
            // 找不到变量声明
            return D_UNKNOWN;
        }
        return get_scope(parent_scope).get_symbol_dec_type(symbol);
    }
    return it->second.first;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x29a8e
leaq 0x18(%r14), %rcx
cmpq %rcx, %rax
jne 0x28363
movq (%r14), %rdi
cmpq 0x8(%r14), %rdi
je 0x28368
callq 0x28370
movq %rax, %r14
jmp 0x2833b
movl 0x40(%rax), %eax
jmp 0x2836a
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::get_scope(unsigned long)
ParseScope &ParseScope::get_scope(size_t scope_id) {
    if (scopes.empty()) {
        init();
    }
    if (scope_id >= scopes.size()) {
        return scopes[0];
    }
    return scopes[scope_id];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2c040(%rip), %rcx     # 0x543c0
movq 0x2c041(%rip), %rdx     # 0x543c8
cmpq %rdx, %rcx
jne 0x2839f
callq 0x2928c
movq 0x2c030(%rip), %rdx     # 0x543c8
movq 0x2c021(%rip), %rcx     # 0x543c0
subq %rcx, %rdx
sarq $0x6, %rdx
xorl %eax, %eax
cmpq %rbx, %rdx
cmovaq %rbx, %rax
shlq $0x6, %rax
addq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::declaration(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ParseType const&)
void ParseScope::declaration(const string &symbol, const ParseType &type) {
    if (symbol.empty()) {
        printf("ParseDeclaration(const string &symbol, const ParseType &type): 警告: 试图声明空符号\n");
        return;
    }
    auto it = symbol2dec_ptr.find(symbol);
    if (it != symbol2dec_ptr.end()) {
        printf("ParseDeclaration(const string &symbol, const ParseVariable &variable): 警告: 试图重声明符号"
               "%s 为 类型:%s 跳过该操作\n", symbol.c_str(), type.get_info().c_str());
        return;
    }
    vector<size_t> type_id;
    type_id.emplace_back(type.get_id());
    symbol2dec_ptr[symbol] = pair<DeclarationType, vector<size_t> >(D_TYPE, type_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
cmpq $0x0, 0x8(%rsi)
je 0x28422
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x29b18
addq $0x18, %r12
cmpq %r12, %rax
je 0x2843a
movq (%rbx), %rbx
leaq -0x60(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x215a0
movq (%r14), %rdx
leaq 0x134dc(%rip), %rdi     # 0x3b8ea
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4060
movq %r14, %rdi
callq 0x4598
jmp 0x2849e
leaq 0x13ac8(%rip), %rdi     # 0x3bef1
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4430
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
movq %r15, %rdi
callq 0x212de
leaq -0x60(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x1679a
leaq -0x58(%rbp), %r15
movl $0x3, -0x8(%r15)
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x1fa14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29554
leaq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x295be
movq %r15, %rdi
callq 0xd238
leaq -0x40(%rbp), %rdi
callq 0xd238
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0xd238
jmp 0x284bd
jmp 0x284ba
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xd238
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::declaration(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ParseVariable const&)
void ParseScope::declaration(const string &symbol, const ParseVariable &variable) {
    if (symbol.empty()) {
        printf("ParseDeclaration(const string &symbol, const ParseVariable &variable): 警告: 试图声明空符号\n");
        return;
    }
    auto it = symbol2dec_ptr.find(symbol);
    if (it != symbol2dec_ptr.end()) {
        printf("ParseDeclaration(const string &symbol, const ParseVariable &variable): 警告: 试图重声明符号"
               "%s 为 变量:%s 跳过该操作\n", symbol.c_str(), variable.get_info().c_str());
        return;
    }
    vector<size_t> var_ptr;
    var_ptr.emplace_back((size_t) new ParseVariable(variable));
    symbol2dec_ptr[symbol] = pair<DeclarationType, vector<size_t> >(D_VARIABLE, var_ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
cmpq $0x0, 0x8(%rsi)
je 0x28535
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x29b18
addq $0x18, %r12
cmpq %r12, %rax
je 0x2854d
movq (%rbx), %rbx
leaq -0x60(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x273ac
movq (%r14), %rdx
leaq 0x13452(%rip), %rdi     # 0x3b970
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4060
movq %r14, %rdi
callq 0x4598
jmp 0x285bf
leaq 0x13a12(%rip), %rdi     # 0x3bf4e
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4430
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
pushq $0x68
popq %rdi
callq 0x42a0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x2761e
leaq -0x60(%rbp), %rsi
movq %r12, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x1679a
leaq -0x58(%rbp), %r15
movl $0x2, -0x8(%r15)
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x1fa14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29554
leaq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x295be
movq %r15, %rdi
callq 0xd238
leaq -0x40(%rbp), %rdi
callq 0xd238
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0xd238
jmp 0x285eb
jmp 0x285e8
movq %rax, %rbx
movq %r12, %rdi
callq 0x4270
jmp 0x285eb
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xd238
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::get_variable_declaration(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
ParseVariable ParseScope::get_variable_declaration(const string &symbol) const {
    auto it = symbol2dec_ptr.find(symbol);
    if (it == symbol2dec_ptr.end()) {
        if (parent_scope == this_scope) {
            // 找不到变量声明
            string info = "ParseScope::get_variable_declaration(const string &symbol) symbol=" + symbol;
            throw ParseException(EX_NOT_DECLARED, info);
        }
        return get_scope(parent_scope).get_variable_declaration(symbol);
    }
    if (it->second.first != D_VARIABLE) {
        // 非变量声明
        string info = "ParseScope::get_variable_declaration(const string &symbol) symbol=" + symbol;
        throw ParseException(EX_DECLARATION_NOT_A_VARIABLE, info);
    }
    const auto &var_ptr_list = it->second.second;
    if (var_ptr_list.empty()) {
        // 声明了变量但是找不到其记录(BUG)
        string info = "ParseScope::get_variable_declaration(const string &symbol) symbol=" + symbol;
        throw ParseException(EX_DECLARATION_NOT_FOUND, info);
    }
    return *((ParseVariable *) var_ptr_list[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x29a8e
leaq 0x18(%r15), %rcx
cmpq %rcx, %rax
jne 0x28d34
movq (%r15), %rdi
cmpq 0x8(%r15), %rdi
je 0x28d61
callq 0x28370
movq %rax, %r15
jmp 0x28d0c
cmpl $0x2, 0x40(%rax)
jne 0x28dab
movq 0x48(%rax), %rcx
cmpq 0x50(%rax), %rcx
je 0x28df2
movq (%rcx), %rsi
movq %r14, %rdi
callq 0x2761e
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12f71(%rip), %rsi     # 0x3bcd9
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0xcad6
pushq $0x28
popq %rdi
callq 0x4180
movq %rax, %r14
pushq $0x7
popq %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2b53c
leaq 0x29fd9(%rip), %rsi     # 0x52d70
leaq -0x1c4f6(%rip), %rdx    # 0xc8a8
movq %r14, %rdi
callq 0x44e0
jmp 0x28e37
leaq 0x12f27(%rip), %rsi     # 0x3bcd9
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0xcad6
pushq $0x28
popq %rdi
callq 0x4180
movq %rax, %r14
pushq $0x8
popq %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2b53c
leaq 0x29f8f(%rip), %rsi     # 0x52d70
leaq -0x1c540(%rip), %rdx    # 0xc8a8
movq %r14, %rdi
callq 0x44e0
jmp 0x28e37
leaq 0x12ee0(%rip), %rsi     # 0x3bcd9
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0xcad6
pushq $0x28
popq %rdi
callq 0x4180
movq %rax, %r14
pushq $0xa
popq %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2b53c
leaq 0x29f48(%rip), %rsi     # 0x52d70
leaq -0x1c587(%rip), %rdx    # 0xc8a8
movq %r14, %rdi
callq 0x44e0
jmp 0x28e3f
jmp 0x28e44
jmp 0x28e3f
jmp 0x28e44
movq %rax, %rbx
jmp 0x28e4f
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
leaq -0x38(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::emitText2Nasm[abi:cxx11]()
map<string, ParseFunction> ParseScope::emitText2Nasm() {
    map<string, ParseFunction> sectionText;
    for (const auto &scope: scopes) {
        const auto &symbol2dec = scope.symbol2dec_ptr;
        for (const auto &each : symbol2dec) {
            if (each.first.empty()) {
                continue;
            }
            DeclarationType dec_type = each.second.first;
            switch (dec_type) {
                case D_FUNCTION: {
                    const auto &func_ptr_list = each.second.second;
                    for (const auto &func_ptr:func_ptr_list) {
                        sectionText[((ParseFunction *) func_ptr)->get_symbol()] = *((ParseFunction *) func_ptr);
                    }
                    break;
                }
                default: {
                    break;
                }
            }
        }
    }
    return sectionText;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq 0x2b3a3(%rip), %rdx     # 0x543c0
movq 0x2b3a4(%rip), %rcx     # 0x543c8
movq %rcx, -0x38(%rbp)
leaq -0x68(%rbp), %r14
cmpq -0x38(%rbp), %rdx
je 0x290bf
movq 0x28(%rdx), %rax
leaq 0x18(%rdx), %rcx
movq %rcx, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
cmpq -0x48(%rbp), %rax
je 0x290b6
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x28(%rax)
je 0x290a7
movq -0x30(%rbp), %rax
cmpl $0x1, 0x40(%rax)
jne 0x290a7
movq -0x30(%rbp), %rax
movq 0x48(%rax), %r13
movq 0x50(%rax), %r15
cmpq %r15, %r13
je 0x290a7
movq (%r13), %r12
leaq 0x38(%r12), %rsi
movq %r14, %rdi
callq 0x43a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29606
movq %rax, %rdi
movq %r12, %rsi
callq 0x29670
movq %r14, %rdi
callq 0x4598
addq $0x8, %r13
jmp 0x2906d
movq -0x30(%rbp), %rdi
callq 0x42f0
movq -0x40(%rbp), %rdx
jmp 0x29046
addq $0x40, %rdx
jmp 0x2902c
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x290e2
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x29924
movq %r14, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::emitData2Nasm[abi:cxx11]()
map<string, ParseVariable> ParseScope::emitData2Nasm() {
    map<string, ParseVariable> sectionData;
    for (const auto &scope: scopes) {
        const auto &symbol2dec = scope.symbol2dec_ptr;
        string scope_str = to_string(scope.this_scope) + "@";
        for (const auto &each : symbol2dec) {
            if (each.first.empty()) {
                continue;
            }
            DeclarationType dec_type = each.second.first;
            switch (dec_type) {
                case D_VARIABLE: {
                    if (each.second.second.empty()) {
                        continue;
                    }
                    const auto &var_ptr = each.second.second[0];
                    string var_name = scope_str + ((ParseVariable *) var_ptr)->get_symbol();
                    ParseVariable var = *((ParseVariable *) var_ptr);
                    sectionData[var_name] = var;
                    break;
                }
                default: {
                    break;
                }
            }
        }
    }
    return sectionData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rdi, -0x30(%rbp)
andq $0x0, 0x28(%rdi)
movq 0x2b295(%rip), %rbx     # 0x543c0
movq 0x2b296(%rip), %rax     # 0x543c8
movq %rax, -0x38(%rbp)
leaq -0xe8(%rbp), %r14
leaq -0x80(%rbp), %r13
cmpq -0x38(%rbp), %rbx
je 0x2921d
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0xc865
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
leaq 0x12be7(%rip), %rdx     # 0x3bd4c
callq 0xc8d6
movq %r14, %rdi
callq 0x4598
movq 0x28(%rbx), %r15
movq %rbx, -0x40(%rbp)
leaq 0x18(%rbx), %r12
cmpq %r12, %r15
je 0x29207
cmpq $0x0, 0x28(%r15)
je 0x291f7
cmpl $0x2, 0x40(%r15)
jne 0x291f7
movq 0x48(%r15), %rbx
cmpq 0x50(%r15), %rbx
je 0x291f7
movq (%rbx), %rsi
addq $0x38, %rsi
movq %r14, %rdi
callq 0x43a0
movq %r13, %rdi
leaq -0x60(%rbp), %rsi
movq %r14, %rdx
callq 0x296ac
movq %r14, %rdi
callq 0x4598
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2761e
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x296da
movq %rax, %rdi
movq %r14, %rsi
callq 0x275e6
movq %r14, %rdi
callq 0xca7e
movq %r13, %rdi
callq 0x4598
movq %r15, %rdi
callq 0x42f0
movq %rax, %r15
jmp 0x2917e
leaq -0x60(%rbp), %rdi
callq 0x4598
movq -0x40(%rbp), %rbx
addq $0x40, %rbx
jmp 0x29141
movq -0x30(%rbp), %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2927b
movq %rax, %r14
leaq -0xe8(%rbp), %rdi
jmp 0x29276
movq %rax, %r14
jmp 0x29269
movq %rax, %r14
leaq -0xe8(%rbp), %rdi
jmp 0x2926d
movq %rax, %r14
jmp 0x29272
movq %rax, %r14
leaq -0xe8(%rbp), %rdi
callq 0xca7e
leaq -0x80(%rbp), %rdi
callq 0x4598
leaq -0x60(%rbp), %rdi
callq 0x4598
movq -0x30(%rbp), %rdi
callq 0x299bc
movq %r14, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::init()
void ParseScope::init() {
    scopes.emplace_back(0);
    ParseScope &static_scope = scopes[0];
    vector<size_t> ptr;
    ptr.emplace_back(0);
    // 默认
    static_scope.symbol2dec_ptr[string()] = pair<DeclarationType, vector<size_t> >(D_UNKNOWN, ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq -0x70(%rbp), %rbx
andl $0x0, (%rbx)
leaq 0x2b11b(%rip), %rdi     # 0x543c0
movq %rbx, %rsi
callq 0x29744
movq 0x2b10c(%rip), %r14     # 0x543c0
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rdi
andq $0x0, 0x10(%rdi)
movaps %xmm0, (%rdi)
andl $0x0, (%rbx)
leaq -0x70(%rbp), %rsi
callq 0x26732
leaq -0x68(%rbp), %rbx
andl $0x0, -0x8(%rbx)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x1fa14
addq $0x10, %r14
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x2978a
leaq -0x70(%rbp), %rsi
movq %rax, %rdi
callq 0x295be
leaq -0x50(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0xd238
leaq -0x30(%rbp), %rdi
callq 0xd238
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0xd238
jmp 0x2934d
jmp 0x2934a
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0xd238
movq %r14, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::new_scope(unsigned long)
size_t ParseScope::new_scope(size_t parent) {
    if (scopes.empty()) {
        init();
    }
    if (parent >= scopes.size()) {
        printf("ParseDeclaration::new_scope(size_t parent): 警告: 试图获取不存在的作用域%zu\n", parent);
        return 0;
    }
    scopes.emplace_back(parent);
    scopes[scopes.size() - 1].this_scope = scopes.size() - 1;
    return scopes.size() - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rdi, -0x18(%rbp)
movq 0x2b049(%rip), %rcx     # 0x543c0
movq 0x2b04a(%rip), %rax     # 0x543c8
cmpq %rax, %rcx
jne 0x29396
callq 0x2928c
movq 0x2b039(%rip), %rax     # 0x543c8
movq 0x2b02a(%rip), %rcx     # 0x543c0
subq %rcx, %rax
sarq $0x6, %rax
cmpq %rbx, %rax
jbe 0x293d8
leaq 0x2b017(%rip), %rdi     # 0x543c0
leaq -0x18(%rbp), %rsi
callq 0x297f4
movq 0x2b00f(%rip), %r14     # 0x543c8
movq 0x2b000(%rip), %rax     # 0x543c0
subq %rax, %r14
sarq $0x6, %r14
decq %r14
movq %r14, %rcx
shlq $0x6, %rcx
movq %r14, 0x8(%rax,%rcx)
jmp 0x293ec
leaq 0x1296f(%rip), %rdi     # 0x3bd4e
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4060
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::~ParseScope()
ParseScope::~ParseScope() {
    for (const auto &each : symbol2dec_ptr) {
        switch (each.second.first) {
            case D_UNKNOWN:
            case D_TYPE:
                break;
            case D_FUNCTION:
                for (const auto &each_ptr : each.second.second) {
                    delete (ParseFunction *) (each_ptr);
                }
                break;
            case D_VARIABLE:
                for (const auto &each_ptr : each.second.second) {
                    delete (ParseVariable *) (each_ptr);
                }
                break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rdi), %r14
movq %rdi, -0x30(%rbp)
leaq 0x18(%rdi), %r12
cmpq %r12, %r14
je 0x2948a
movl 0x40(%r14), %eax
cmpl $0x2, %eax
je 0x29451
cmpl $0x1, %eax
jne 0x2947d
movq 0x48(%r14), %r13
movq 0x50(%r14), %rbx
cmpq %rbx, %r13
je 0x2947d
movq (%r13), %r15
testq %r15, %r15
je 0x29443
movq %r15, %rdi
callq 0xcdb4
movq %r15, %rdi
callq 0x4270
addq $0x8, %r13
jmp 0x2942d
movq 0x48(%r14), %r13
movq 0x50(%r14), %rbx
cmpq %rbx, %r13
je 0x2947d
movq (%r13), %r15
testq %r15, %r15
je 0x2946f
movq %r15, %rdi
callq 0xca7e
movq %r15, %rdi
callq 0x4270
addq $0x8, %r13
jmp 0x29459
movq %r14, %rdi
callq 0x4210
movq %rax, %r14
jmp 0x29412
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2988c
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::get_all_dec_symbol[abi:cxx11]() const
vector<string> ParseScope::get_all_dec_symbol() const {
    vector<string> list;
    for (const auto &each : symbol2dec_ptr) {
        if (each.first.empty()) {
            continue;
        }
        list.emplace_back(each.first);
    }
    return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x28(%rsi), %r15
addq $0x18, %r14
cmpq %r14, %r15
je 0x29506
cmpq $0x0, 0x28(%r15)
je 0x294f9
leaq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x29850
movq %r15, %rdi
callq 0x42f0
movq %rax, %r15
jmp 0x294e1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xd092
movq %r14, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseTreeErrorHandle.cpp
// Function: ParseTree::last_combine()
void ParseTree::last_combine() {
    int idx = 0;
    set<size_t> tmp_nodes(last_nodes);
    for (auto i : tmp_nodes) {
        if (idx >= error_nodes.size()) {
#ifdef PARSE_TREE_DEBUG
            puts("ParseTree::last_combine log: OUT RANGE OF ERROR NODES.");
#endif
            break;
        }
        if (i == error_nodes[idx]) {
#ifdef PARSE_TREE_DEBUG
            puts("ParseTree::last_combine log: SAME TAG ERROR AND LAST OF NODE.");
#endif
            continue;
        }
        if (i > error_nodes[idx]) { // 必须在逻辑上保证错误节点不是剩余节点
            idx++;
        }
        if (native_root(error_nodes[idx]) == i) { // 错误结点位于以 i 为根的树
            continue;
        }
        set_parent(i, error_nodes[idx]); // 必须保证在程序正确的情况下错误节点能容纳所有剩余节点
    }
    for (auto i : last_nodes) {
        set_parent(i, 0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x78(%rdi), %rsi
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x2b374
movq 0x18(%r14), %r14
xorl %r13d, %r13d
leaq -0x50(%rbp), %rax
cmpq %rax, %r14
je 0x2aecb
movslq %r13d, %rcx
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rcx, %rdx
jbe 0x2aebf
movq 0x20(%r14), %r12
movq (%rax,%rcx,8), %rcx
cmpq %rcx, %r12
jne 0x2ae84
leaq 0x11260(%rip), %rdi     # 0x3c0dd
callq 0x4430
jmp 0x2aeb2
cmpq %r12, %rcx
adcl $0x0, %r13d
movslq %r13d, %r15
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x2af28
cmpq %r12, %rax
je 0x2aeb2
movq 0x48(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x153d8
movq %r14, %rdi
callq 0x42f0
movq %rax, %r14
jmp 0x2ae49
leaq 0x111e0(%rip), %rdi     # 0x3c0a6
callq 0x4430
movq 0x90(%rbx), %r14
leaq 0x80(%rbx), %r15
cmpq %r15, %r14
je 0x2aef9
movq 0x20(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x153d8
movq %r14, %rdi
callq 0x42f0
movq %rax, %r14
jmp 0x2aed9
leaq -0x58(%rbp), %rdi
callq 0x11412
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2af13
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x11412
movq %rbx, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseTreeErrorHandle.cpp
// Function: ParseTree::native_root(unsigned long)
size_t ParseTree::native_root(size_t idx) {
    size_t p = idx, last;
    while (get_parent(p) != (size_t) (-1)) {
        last = p;
        p = get_parent(p);
        if (p == last) {
            return p;
        }
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x154ee
cmpq $-0x1, %rax
je 0x2af59
movq %rbx, %rdi
movq %r14, %rsi
callq 0x154ee
cmpq %r14, %rax
jne 0x2af35
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseTreeErrorHandle.cpp
// Function: ParseTree::watch_children_nodes() const
void ParseTree::watch_children_nodes() const {
    printf("node_children[%zu]\n", node_children.size());
    for (int i = 0; i < node_children.size(); i++) {
        printf("node_children[%i] size %zu: ", i, node_children[i].size());
        for (auto j : node_children[i]) {
            printf("%zu ", j);
        }
        printf("\n");
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rax
subq 0x60(%rdi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
leaq 0x11191(%rip), %rdi     # 0x3c11b
movq %rax, %rsi
xorl %eax, %eax
callq 0x4060
leaq 0xfe91(%rip), %r12      # 0x3ae2c
xorl %r13d, %r13d
movq 0x60(%rbx), %rcx
movq 0x68(%rbx), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %r13, %rax
jbe 0x2b00a
imulq $0x18, %r13, %r15
movq 0x8(%rcx,%r15), %rdx
subq (%rcx,%r15), %rdx
sarq $0x3, %rdx
leaq 0x11161(%rip), %rdi     # 0x3c12f
movl %r13d, %esi
xorl %eax, %eax
callq 0x4060
movq 0x60(%rbx), %rax
movq (%rax,%r15), %r14
movq 0x8(%rax,%r15), %r15
cmpq %r15, %r14
je 0x2affd
movq (%r14), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x4060
addq $0x8, %r14
jmp 0x2afe5
pushq $0xa
popq %rdi
callq 0x43b0
incq %r13
jmp 0x2af9e
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43b0
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseTreeErrorHandle.cpp
// Function: ParseTree::watch_last_nodes() const
void ParseTree::watch_last_nodes() const {
    printf("last_nodes[%zu]\n", last_nodes.size());
    for (auto i : last_nodes) {
        printf("%zu %s\n", i, get_msg(i).c_str());
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0xa0(%rdi), %rsi
leaq 0x1110a(%rip), %rdi     # 0x3c14c
xorl %eax, %eax
callq 0x4060
movq 0x90(%rbx), %r12
leaq 0x80(%rbx), %r15
leaq -0x48(%rbp), %r14
cmpq %r15, %r12
je 0x2b09d
movq 0x20(%r12), %r13
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x152a8
movq -0x48(%rbp), %rdx
leaq 0x110df(%rip), %rdi     # 0x3c15d
movq %r13, %rsi
xorl %eax, %eax
callq 0x4060
movq %r14, %rdi
callq 0x4598
movq %r12, %rdi
callq 0x42f0
movq %rax, %r12
jmp 0x2b05b
pushq $0xa
popq %rdi
callq 0x43b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseTreeErrorHandle.cpp
// Function: ParseTree::watch_error_nodes() const
void ParseTree::watch_error_nodes() const {
    printf("error_nodes[%zu]\n", error_nodes.size());
    for (auto i : error_nodes) {
        printf("%zu %s\n", i, get_msg(i).c_str());
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x50(%rdi), %rsi
subq 0x48(%rdi), %rsi
sarq $0x3, %rsi
leaq 0x1108a(%rip), %rdi     # 0x3c165
xorl %eax, %eax
callq 0x4060
movq 0x48(%rbx), %r13
movq 0x50(%rbx), %r15
leaq -0x48(%rbp), %r14
cmpq %r15, %r13
je 0x2b128
movq (%r13), %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x152a8
movq -0x48(%rbp), %rdx
leaq 0x1104d(%rip), %rdi     # 0x3c15d
movq %r12, %rsi
xorl %eax, %eax
callq 0x4060
movq %r14, %rdi
callq 0x4598
addq $0x8, %r13
jmp 0x2b0ee
pushq $0xa
popq %rdi
callq 0x43b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseTreeErrorHandle.cpp
// Function: ParseTree::format_error(unsigned long, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string ParseTree::format_error(size_t eid, size_t pid, const string & input_file, const string &error_string) {
    string ret = "";
    if (eid != (size_t)-1 && pid != (size_t)-1) {
        ret += input_file + ": In " + to_string(pid) + ": " + get_msg(pid) + "\n";
    } else {
        ret += input_file + ":\n";
    }
    ret += error_string + "\n";
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r9, -0x50(%rbp)
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x115b4(%rip), %rsi     # 0x3c722
leaq -0x48(%rbp), %rdx
callq 0x4130
cmpq $-0x1, %r14
sete %al
cmpq $-0x1, %r15
sete %cl
orb %al, %cl
jne 0x2b27a
leaq 0x10fe3(%rip), %rdx     # 0x3c177
leaq -0xb0(%rbp), %rdi
movq %r13, %rsi
callq 0xca9e
leaq -0x90(%rbp), %rdi
movq %r15, %rsi
callq 0xc865
leaq -0xd0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0xc95f
leaq 0xceb2(%rip), %rdx      # 0x38085
leaq -0xf0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0xc8d6
leaq -0x70(%rbp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x152a8
leaq -0x110(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xc95f
leaq 0xf124(%rip), %rdx      # 0x3a337
leaq -0x48(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0xc8d6
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x4580
leaq -0x48(%rbp), %rdi
callq 0x4598
leaq -0x110(%rbp), %rdi
callq 0x4598
leaq -0x70(%rbp), %rdi
callq 0x4598
leaq -0xf0(%rbp), %rdi
callq 0x4598
leaq -0xd0(%rbp), %rdi
callq 0x4598
leaq -0x90(%rbp), %rdi
callq 0x4598
leaq -0xb0(%rbp), %rdi
jmp 0x2b29d
leaq 0xdbd8(%rip), %rdx      # 0x38e59
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0xca9e
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x4580
leaq -0x48(%rbp), %rdi
callq 0x4598
leaq 0xf08e(%rip), %rdx      # 0x3a337
leaq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xca9e
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x4580
leaq -0x48(%rbp), %rdi
callq 0x4598
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x4598
jmp 0x2b2f1
movq %rax, %r14
leaq -0x110(%rbp), %rdi
callq 0x4598
jmp 0x2b302
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x4598
jmp 0x2b310
movq %rax, %r14
leaq -0xf0(%rbp), %rdi
callq 0x4598
jmp 0x2b321
movq %rax, %r14
leaq -0xd0(%rbp), %rdi
callq 0x4598
leaq -0x90(%rbp), %rdi
callq 0x4598
leaq -0xb0(%rbp), %rdi
jmp 0x2b359
movq %rax, %r14
jmp 0x2b32d
jmp 0x2b352
movq %rax, %r14
jmp 0x2b339
jmp 0x2b360
jmp 0x2b360
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x4598
jmp 0x2b363
movq %rax, %r14
movq %rbx, %rdi
callq 0x4598
movq %r14, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseException.cpp
// Function: ParseException::get_info[abi:cxx11]() const
string ParseException::get_info() const {
    string temp_what = "ParseException {\n  code:";
    temp_what += get_code_msg(code) + ",\n";
    for (const auto &each : trace) {
        temp_what += "  " + each + ",\n";
    }
    temp_what += "}";
    return temp_what;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
leaq 0x10c26(%rip), %rsi     # 0x3c1e9
leaq -0x50(%rbp), %rdx
movq %rdi, -0x30(%rbp)
callq 0x4130
movl 0x8(%r15), %esi
leaq -0x70(%rbp), %rdi
callq 0x2b6ca
leaq 0x11139(%rip), %rdx     # 0x3c71d
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xc8d6
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x4580
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x4598
leaq -0x70(%rbp), %r12
movq %r12, %rdi
callq 0x4598
movq 0x10(%r15), %r13
movq 0x18(%r15), %r15
leaq 0x110f8(%rip), %rbx     # 0x3c71d
cmpq %r15, %r13
je 0x2b66c
movq %r12, %rdi
leaq 0xf07c(%rip), %rsi      # 0x3a6b0
movq %r13, %rdx
callq 0xcad6
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xc8d6
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x4580
movq %r14, %rdi
callq 0x4598
movq %r12, %rdi
callq 0x4598
addq $0x20, %r13
jmp 0x2b625
leaq 0xfba5(%rip), %rsi      # 0x3b218
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x4540
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b699
jmp 0x2b6a3
jmp 0x2b69e
jmp 0x2b699
movq %rax, %r14
jmp 0x2b6b8
movq %rax, %r14
jmp 0x2b6af
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x4598
leaq -0x70(%rbp), %rdi
callq 0x4598
movq -0x30(%rbp), %rdi
callq 0x4598
movq %r14, %rdi
callq 0x4500
nop