LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f193
leaq 0x175ba(%rip), %rcx     # 0x4671c
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 0x17d39(%rip), %rdi     # 0x46ed7
callq 0x4480
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f1dd
leaq 0x17d5a(%rip), %rdi     # 0x46f17
callq 0x4480
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1615c(%rip), %rdx     # 0x4532c
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xf868
jmp 0x2f1fa
movq 0x8(%rsi), %rax
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xf7ca
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::~ParseConstant()
ParseConstant::~ParseConstant() {
    switch (type) {
        case C_STRING:
            delete (string *) value;
            break;
        case C_SIGNED:
            delete (long long *) value;
            break;
        case C_UNSIGNED:
            delete (unsigned *) value;
            break;
        case C_FLOAT:
            delete (long double *) value;
            break;
        case C_BOOL:
            delete (bool *) value;
            break;
        case C_UNDEFINED:
            break;
    }
}

// Assembly:
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x2f253
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x17513(%rip), %rcx     # 0x4672c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x42b0
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x2f226
movq (%rbx), %rdi
movq %rbx, %rax
addq $0x10, %rax
cmpq %rax, %rdi
je 0x2f226
callq 0x42b0
jmp 0x2f226
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x4, %esi
ja 0x2f2cb
movl %esi, %eax
leaq 0x174ce(%rip), %rcx     # 0x46740
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x175b3(%rip), %rsi     # 0x46835
leaq 0x175b8(%rip), %rdx     # 0x46841
jmp 0x2f2d9
leaq 0x175e0(%rip), %rsi     # 0x46872
leaq 0x175e3(%rip), %rdx     # 0x4687c
jmp 0x2f2d9
leaq 0x175b1(%rip), %rsi     # 0x46853
leaq 0x175bc(%rip), %rdx     # 0x46865
jmp 0x2f2d9
leaq 0x175b4(%rip), %rsi     # 0x46866
leaq 0x175b8(%rip), %rdx     # 0x46871
jmp 0x2f2d9
leaq 0x17580(%rip), %rsi     # 0x46842
leaq 0x17589(%rip), %rdx     # 0x46852
jmp 0x2f2d9
leaq 0x17026(%rip), %rsi     # 0x462f8
leaq 0x17028(%rip), %rdx     # 0x46301
movq %rbx, %rdi
callq 0xf868
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x50, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x5, %rax
ja 0x2f3d2
leaq 0x17447(%rip), %rcx     # 0x46754
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdx
leaq 0x1755c(%rip), %rsi     # 0x4687d
movq %rbx, %rdi
callq 0xe95b
jmp 0x2f3ef
movq 0x8(%rsi), %rax
leaq 0x16807(%rip), %rcx     # 0x45b40
leaq 0x16805(%rip), %rdx     # 0x45b45
cmpb $0x0, (%rax)
cmovneq %rcx, %rdx
leaq 0x17579(%rip), %rsi     # 0x468c7
jmp 0x2f38e
movq 0x8(%rsi), %rax
movq (%rax), %rdx
leaq 0x17541(%rip), %rsi     # 0x4689f
jmp 0x2f38e
movq 0x8(%rsi), %rax
fldt (%rax)
fstpt (%rsp)
leaq 0x17544(%rip), %rsi     # 0x468b4
leaq -0x50(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x40c0
jmp 0x2f39c
movq 0x8(%rsi), %rax
movq (%rax), %rdx
leaq 0x174fe(%rip), %rsi     # 0x4688c
leaq -0x50(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x40c0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x4170
leaq (%rax,%rbp), %rdx
addq $-0x50, %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x2f3ea
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x16f2f(%rip), %rsi     # 0x462f8
leaq 0x16f31(%rip), %rdx     # 0x46301
jmp 0x2f3e7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x16227(%rip), %rsi     # 0x45607
leaq 0x16227(%rip), %rdx     # 0x4560e
movq %rbx, %rdi
callq 0xf868
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f574
movl %esi, %eax
leaq 0x17251(%rip), %rcx     # 0x46780
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl %ebx, %esi
jne 0x2f574
movl %esi, %eax
jmp 0x2f5cc
leal -0x1(%rbx), %eax
cmpl $0x3, %eax
jae 0x2f574
movl %ebx, %eax
jmp 0x2f5cc
leal -0x1(%rbx), %ecx
movl $0x3, %eax
cmpl $0x3, %ecx
jae 0x2f574
jmp 0x2f5cc
leal -0x1(%rbx), %eax
cmpl $0x3, %eax
jae 0x2f574
movl %eax, %eax
leaq 0x1724d(%rip), %rcx     # 0x467bc
movl (%rcx,%rax,4), %eax
jmp 0x2f5cc
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x2f254
movq (%r14), %r14
leaq -0x50(%rbp), %rdi
movl %ebx, %esi
callq 0x2f254
leaq -0x40(%rbp), %rbx
movq -0x10(%rbx), %rdx
leaq 0x17339(%rip), %rdi     # 0x468d6
movq %r14, %rsi
xorl %eax, %eax
callq 0x4070
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x2f5b5
callq 0x42b0
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f5c7
callq 0x42b0
movl $0x5, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f5ea
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/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
addq $0x10, %rdi
callq 0x31664
leaq 0x18(%r14), %rcx
cmpq %rcx, %rax
jne 0x2f987
movq (%r14), %rdi
cmpq 0x8(%r14), %rdi
je 0x2f98f
callq 0x2f994
movq %rax, %r14
leaq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x31664
movq %r14, %rcx
addq $0x18, %rcx
jmp 0x2f95c
movl 0x40(%rax), %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x2f98a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2ca4c(%rip), %rcx     # 0x5c3f0
movq 0x2ca4d(%rip), %rdx     # 0x5c3f8
cmpq %rdx, %rcx
jne 0x2f9c3
callq 0x30ce0
movq 0x2ca3c(%rip), %rdx     # 0x5c3f8
movq 0x2ca2d(%rip), %rcx     # 0x5c3f0
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_O3/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 0x2fa5a
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x31702
addq $0x18, %r12
cmpq %r12, %rax
je 0x2fa72
movq (%rbx), %rbx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x273f2
movq (%r14), %rdx
leaq 0x16f20(%rip), %rdi     # 0x46952
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
movq (%r14), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x2fa4d
callq 0x42b0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x174f8(%rip), %rdi     # 0x46f59
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4480
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movq $0x0, -0x50(%rbp)
movq %r15, %rdi
callq 0x270b4
leaq -0x40(%rbp), %rdx
movq %rax, (%rdx)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x19328
leaq -0x38(%rbp), %r15
movl $0x3, -0x8(%r15)
leaq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x25a6a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3106c
movl -0x40(%rbp), %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
testq %rdi, %rdi
je 0x2fb06
callq 0x42b0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x2fb06
callq 0x42b0
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
jne 0x2fa48
jmp 0x2fa4d
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x2fb30
callq 0x42b0
jmp 0x2fb30
jmp 0x2fb2d
movq %rax, %rbx
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x2fb3e
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2fbbe
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x31702
addq $0x18, %r12
cmpq %r12, %rax
je 0x2fbd6
movq (%rbx), %rbx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e3c4
movq (%r14), %rdx
leaq 0x16e42(%rip), %rdi     # 0x469d8
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
movq (%r14), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x2fbb1
callq 0x42b0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x173f1(%rip), %rdi     # 0x46fb6
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4480
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movq $0x0, -0x50(%rbp)
movl $0x68, %edi
callq 0x42e0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e874
leaq -0x40(%rbp), %rdx
movq %r12, (%rdx)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x19328
leaq -0x38(%rbp), %r15
movl $0x2, -0x8(%r15)
leaq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x25a6a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3106c
movl -0x40(%rbp), %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
testq %rdi, %rdi
je 0x2fc7a
callq 0x42b0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x2fc7a
callq 0x42b0
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
jne 0x2fbac
jmp 0x2fbb1
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
jne 0x2fca2
jmp 0x2fcac
jmp 0x2fca9
movq %rax, %rbx
movq %r12, %rdi
callq 0x42b0
jmp 0x2fcac
movq %rax, %rbx
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x2fcba
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/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(%rsi), %rdi
movq %rdx, %rsi
callq 0x31664
leaq 0x18(%r15), %rcx
cmpq %rcx, %rax
jne 0x30561
movq (%r15), %rdi
cmpq 0x8(%r15), %rdi
je 0x3058e
callq 0x2f994
movq %rax, %r15
leaq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x31664
movq %r15, %rcx
addq $0x18, %rcx
jmp 0x30536
cmpl $0x2, 0x40(%rax)
jne 0x305dc
movq 0x48(%rax), %rcx
cmpq 0x50(%rax), %rcx
je 0x30627
movq (%rcx), %rsi
movq %r14, %rdi
callq 0x2e874
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x167ac(%rip), %rsi     # 0x46d41
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0xe95b
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
movq %rax, %rdi
movl $0x7, %esi
movq %r15, %rdx
callq 0x333ee
leaq 0x2a7a8(%rip), %rsi     # 0x5ad70
leaq -0x2202f(%rip), %rdx    # 0xe5a0
movq %r14, %rdi
callq 0x4540
jmp 0x30670
leaq 0x1675e(%rip), %rsi     # 0x46d41
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0xe95b
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
movq %rax, %rdi
movl $0x8, %esi
movq %r15, %rdx
callq 0x333ee
leaq 0x2a75a(%rip), %rsi     # 0x5ad70
leaq -0x2207d(%rip), %rdx    # 0xe5a0
movq %r14, %rdi
callq 0x4540
jmp 0x30670
leaq 0x16713(%rip), %rsi     # 0x46d41
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0xe95b
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
movq %rax, %rdi
movl $0xa, %esi
movq %r15, %rdx
callq 0x333ee
leaq 0x2a70f(%rip), %rsi     # 0x5ad70
leaq -0x220c8(%rip), %rdx    # 0xe5a0
movq %r14, %rdi
callq 0x4540
jmp 0x30678
jmp 0x3067d
jmp 0x30678
jmp 0x3067d
movq %rax, %rbx
jmp 0x30688
movq %rax, %rbx
movq %r14, %rdi
callq 0x4250
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3069a
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rdi, -0x38(%rbp)
movq %rcx, 0x28(%rdi)
movq 0x2bb73(%rip), %rdx     # 0x5c3f0
movq 0x2bb74(%rip), %rcx     # 0x5c3f8
movq %rcx, -0x40(%rbp)
cmpq %rcx, %rdx
je 0x3093c
leaq -0x60(%rbp), %r13
leaq -0x70(%rbp), %r14
movq 0x28(%rdx), %rax
movq %rdx, -0x48(%rbp)
leaq 0x18(%rdx), %rcx
movq %rcx, -0x50(%rbp)
cmpq %rcx, %rax
je 0x3092a
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x28(%rax)
je 0x3091b
movq -0x30(%rbp), %rax
cmpl $0x1, 0x40(%rax)
jne 0x3091b
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rbx
movq 0x50(%rax), %r15
cmpq %r15, %rbx
je 0x3091b
movq (%rbx), %r12
movq %r13, -0x70(%rbp)
movq 0x38(%r12), %rsi
movq 0x40(%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xf7ca
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x310ec
movq %rax, %rdi
movq %r12, %rsi
callq 0x3116c
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x30915
callq 0x42b0
addq $0x8, %rbx
jmp 0x308cf
movq -0x30(%rbp), %rdi
callq 0x4350
cmpq -0x50(%rbp), %rax
jne 0x308ae
movq -0x48(%rbp), %rdx
addq $0x40, %rdx
cmpq -0x40(%rbp), %rdx
jne 0x30899
movq -0x38(%rbp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x30965
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x30965
callq 0x42b0
movq -0x38(%rbp), %rdi
callq 0x3150e
movq %r14, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
xorl %r15d, %r15d
leaq -0x38(%rbp), %rbx
movl %r15d, (%rbx)
leaq 0x2b6f2(%rip), %rdi     # 0x5c3f0
movq %rbx, %rsi
callq 0x31228
movq 0x2b6e3(%rip), %r14     # 0x5c3f0
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl %r15d, (%rbx)
leaq -0x38(%rbp), %rdx
xorl %esi, %esi
callq 0x2dc60
leaq -0x30(%rbp), %rbx
movl $0x0, -0x8(%rbx)
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x25a6a
addq $0x10, %r14
leaq -0x60(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq -0x70(%rbp), %rsi
movq %r14, %rdi
callq 0x31270
movl -0x38(%rbp), %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
testq %rdi, %rdi
je 0x30da1
callq 0x42b0
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x30daf
callq 0x42b0
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x30dbd
callq 0x42b0
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x30dcb
callq 0x42b0
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x30de7
callq 0x42b0
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x30dfc
callq 0x42b0
jmp 0x30dfc
jmp 0x30df9
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x30e0a
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b5c5(%rip), %rcx     # 0x5c3f0
movq 0x2b5c6(%rip), %rax     # 0x5c3f8
cmpq %rax, %rcx
jne 0x30e4a
callq 0x30ce0
movq 0x2b5b5(%rip), %rax     # 0x5c3f8
movq 0x2b5a6(%rip), %rcx     # 0x5c3f0
subq %rcx, %rax
sarq $0x6, %rax
cmpq %rbx, %rax
jbe 0x30e8c
leaq 0x2b593(%rip), %rdi     # 0x5c3f0
leaq -0x18(%rbp), %rsi
callq 0x312f0
movq 0x2b58b(%rip), %r14     # 0x5c3f8
movq 0x2b57c(%rip), %rax     # 0x5c3f0
subq %rax, %r14
sarq $0x6, %r14
decq %r14
movq %r14, %rcx
shlq $0x6, %rcx
movq %r14, 0x8(%rax,%rcx)
jmp 0x30ea0
leaq 0x15f23(%rip), %rdi     # 0x46db6
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x30f79
movl 0x40(%r14), %eax
cmpl $0x2, %eax
je 0x30f28
cmpl $0x1, %eax
jne 0x30f65
movq 0x48(%r14), %r13
movq 0x50(%r14), %rbx
cmpq %rbx, %r13
je 0x30f65
movq (%r13), %r15
testq %r15, %r15
je 0x30f1a
leaq 0x58(%r15), %rdi
callq 0xe9e6
movq 0x38(%r15), %rdi
leaq 0x48(%r15), %rax
cmpq %rax, %rdi
je 0x30f12
callq 0x42b0
movq %r15, %rdi
callq 0x27ca8
movq %r15, %rdi
callq 0x42b0
addq $0x8, %r13
jmp 0x30ee9
movq 0x48(%r14), %rbx
movq 0x50(%r14), %r13
cmpq %r13, %rbx
je 0x30f65
movq (%rbx), %r15
testq %r15, %r15
je 0x30f57
movq 0x38(%r15), %rdi
leaq 0x48(%r15), %rax
cmpq %rax, %rdi
je 0x30f4f
callq 0x42b0
movq %r15, %rdi
callq 0x27ca8
movq %r15, %rdi
callq 0x42b0
addq $0x8, %rbx
jmp 0x30f30
movq %r14, %rdi
callq 0x4230
movq %rax, %r14
cmpq %r12, %rax
jne 0x30ecf
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31384
// File: /workspace/github_cpp_makefile_star2_O3/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
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x28(%rsi), %r15
addq $0x18, %r14
cmpq %r14, %r15
je 0x30ffa
cmpq $0x0, 0x28(%r15)
je 0x30fea
leaq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x31338
movq %r15, %rdi
callq 0x4350
movq %rax, %r15
cmpq %r14, %rax
jne 0x30fd7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xf04e
movq %r14, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x33224
movq 0x18(%r14), %r14
leaq -0x50(%rbp), %rax
cmpq %rax, %r14
je 0x329e6
xorl %r15d, %r15d
movslq %r15d, %rcx
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rcx, %rdx
jbe 0x329da
movq 0x20(%r14), %r12
movq (%rax,%rcx,8), %rcx
cmpq %rcx, %r12
jne 0x32996
leaq 0x147b6(%rip), %rdi     # 0x47145
callq 0x4480
jmp 0x329c4
cmpq %r12, %rcx
adcl $0x0, %r15d
movslq %r15d, %r13
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
callq 0x32a46
cmpq %r12, %rax
je 0x329c4
movq 0x48(%rbx), %rax
movq (%rax,%r13,8), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17cde
movq %r14, %rdi
callq 0x4350
movq %rax, %r14
leaq -0x50(%rbp), %rax
cmpq %rax, %r14
jne 0x32964
jmp 0x329e6
leaq 0x1472d(%rip), %rdi     # 0x4710e
callq 0x4480
movq 0x90(%rbx), %r14
leaq 0x80(%rbx), %r15
cmpq %r15, %r14
je 0x32a17
movq 0x20(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x17cde
movq %r14, %rdi
callq 0x4350
movq %rax, %r14
cmpq %r15, %rax
jne 0x329f9
leaq -0x58(%rbp), %rdi
callq 0x13f92
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x32a31
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x13f92
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17e44
cmpq $-0x1, %rax
je 0x32a77
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17e44
cmpq %r14, %rax
jne 0x32a53
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rsi
subq 0x60(%rdi), %rsi
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
leaq 0x146d1(%rip), %rdi     # 0x47183
xorl %eax, %eax
callq 0x4070
movq 0x60(%rbx), %rax
cmpq %rax, 0x68(%rbx)
je 0x32b50
leaq 0x133c6(%rip), %r15     # 0x45e94
xorl %r12d, %r12d
leaq (,%r12,8), %rcx
leaq (%rcx,%rcx,2), %r14
movq 0x8(%rax,%r14), %rdx
subq (%rax,%r14), %rdx
sarq $0x3, %rdx
leaq 0x146a6(%rip), %rdi     # 0x47197
movl %r12d, %esi
xorl %eax, %eax
callq 0x4070
movq 0x60(%rbx), %rax
movq (%rax,%r14), %r13
movq 0x8(%rax,%r14), %r14
cmpq %r14, %r13
je 0x32b21
movq (%r13), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x4070
addq $0x8, %r13
jmp 0x32b08
movl $0xa, %edi
callq 0x43f0
incq %r12
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq %r12, %rcx
ja 0x32ad1
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1462a(%rip), %rdi     # 0x471b4
xorl %eax, %eax
callq 0x4070
movq 0x90(%rbx), %r14
leaq 0x80(%rbx), %r15
cmpq %r15, %r14
je 0x32bf1
leaq 0x1461a(%rip), %r12     # 0x471c5
movq 0x20(%r14), %r13
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x17b48
movq -0x48(%rbp), %rdx
movq %r12, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x4070
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x32be1
callq 0x42b0
movq %r14, %rdi
callq 0x4350
movq %rax, %r14
cmpq %r15, %rax
jne 0x32bab
movl $0xa, %edi
callq 0x43f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1459c(%rip), %rdi     # 0x471cd
xorl %eax, %eax
callq 0x4070
movq 0x48(%rbx), %r13
movq 0x50(%rbx), %r14
cmpq %r14, %r13
je 0x32c8b
leaq 0x14579(%rip), %r15     # 0x471c5
movq (%r13), %r12
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x17b48
movq -0x48(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4070
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x32c82
callq 0x42b0
addq $0x8, %r13
cmpq %r14, %r13
jne 0x32c4c
movl $0xa, %edi
callq 0x43f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x58, %rsp
movq %rsi, %r15
leaq 0x10(%rdi), %rbx
movq %rbx, (%rdi)
leaq 0x13dd1(%rip), %rsi     # 0x47251
leaq 0x13de2(%rip), %rdx     # 0x47269
movq %rdi, -0x30(%rbp)
callq 0xf868
movl 0x8(%r15), %esi
leaq -0x70(%rbp), %rdi
movq %rbx, -0x78(%rbp)
callq 0x33668
leaq 0x142dd(%rip), %rsi     # 0x47785
leaq -0x70(%rbp), %rdi
callq 0x45c0
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x334d5
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x334db
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, -0x48(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x30(%rbp), %rdi
callq 0x4110
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x33511
callq 0x42b0
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x33523
callq 0x42b0
movq 0x10(%r15), %r14
movq 0x18(%r15), %r15
cmpq %r15, %r14
je 0x335d7
leaq -0x70(%rbp), %r12
leaq 0x14246(%rip), %r13     # 0x47785
movq %r12, %rdi
leaq 0x1215b(%rip), %rsi     # 0x456a4
movq %r14, %rdx
callq 0xe95b
movq %r12, %rdi
movq %r13, %rsi
callq 0x45c0
movq %rbx, -0x50(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3357c
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x33582
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, -0x48(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x30(%rbp), %rdi
callq 0x4110
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x335b8
callq 0x42b0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x335ca
callq 0x42b0
addq $0x20, %r14
cmpq %r15, %r14
jne 0x3353f
leaq 0x12ca2(%rip), %rsi     # 0x46280
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x45c0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33620
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x33614
callq 0x42b0
jmp 0x33614
movq %rax, %r14
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
jmp 0x33643
jmp 0x33620
movq %rax, %r14
jmp 0x3364d
movq %rax, %r14
jmp 0x3363b
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3363b
callq 0x42b0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x3364d
callq 0x42b0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq -0x78(%rbp), %rdi
je 0x3365f
callq 0x42b0
movq %r14, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseException.cpp
// Function: ParseException::what() const
const char *ParseException::what() const noexcept {
    const string &info = get_info();
    char *temp = new char[get_info().length() + 1];
    strcpy(temp, get_info().c_str());
    return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x3345e
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x3345e
movq -0x30(%rbp), %rdi
incq %rdi
callq 0x4030
movq %rax, %rbx
leaq -0x28(%rbp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x33895
callq 0x42b0
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x3345e
movq -0x38(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42a0
cmpq %r15, %r14
je 0x338bd
movq %r14, %rdi
callq 0x42b0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x338cf
callq 0x42b0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0xe776
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseExpressionConstCalculate.cpp
// Function: ParseExpression::calculate_const_add(ConstValueType, ParseConstant const&, ParseConstant const&)
void ParseExpression::
calculate_const_add(ConstValueType cal_type,
                    const ParseConstant &const1, const ParseConstant &const2) {
    switch (cal_type) {
        case C_BOOL:
        case C_SIGNED: {
            const_value = (size_t)
                    new ParseConstant(const1.get_signed() + const2.get_signed());
            return;
        }
        case C_UNSIGNED: {
            const_value = (size_t)
                    new ParseConstant(const1.get_unsigned() + const2.get_unsigned());
            return;
        }
        case C_FLOAT: {
            const_value = (size_t)
                    new ParseConstant(const1.get_float() + const2.get_float());
            return;
        }
        case C_STRING:
        default:
            break;
    }
    const_value = (size_t) -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
decl %esi
cmpl $0x3, %esi
ja 0x33ff9
movq %rcx, %r15
movq %rdx, %r12
leaq 0x136a6(%rip), %rax     # 0x475fc
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq %r12, %rdi
callq 0x2efe0
movq %rax, %r12
movq %r15, %rdi
callq 0x2efe0
addq %r12, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x2eed4
jmp 0x34000
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq %r12, %rdi
callq 0x2f04c
movq %rax, %r12
movq %r15, %rdi
callq 0x2f04c
addq %r12, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x2eefe
jmp 0x34000
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq %r12, %rdi
callq 0x2f0d2
fstpt -0x2c(%rbp)
fldz
fstp %st(0)
movq %r15, %rdi
callq 0x2f0d2
fldt -0x2c(%rbp)
faddp %st, %st(1)
fstpt (%rsp)
movq %r14, %rdi
callq 0x2ef50
fldz
fstp %st(0)
jmp 0x34000
movq $-0x1, %r14
movq %r14, 0x18(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
fstp %st(0)
jmp 0x34017
jmp 0x34017
movq %rax, %rbx
movq %r14, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseExpressionConstCalculate.cpp
// Function: ParseExpression::calculate_const_neg(ConstValueType, ParseConstant const&)
void ParseExpression::calculate_const_neg(ConstValueType cal_type, const ParseConstant &constant) {
    switch (cal_type) {
        case C_BOOL:
        case C_SIGNED: {
            const_value = (size_t)
                    new ParseConstant(-constant.get_signed());
            return;
        }
        case C_UNSIGNED: {
            const_value = (size_t)
                    new ParseConstant(-constant.get_unsigned());
            return;
        }
        case C_FLOAT: {
            const_value = (size_t)
                    new ParseConstant(-constant.get_float());
            return;
        }
        case C_STRING:
        default:
            break;
    }
    const_value = (size_t) -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
decl %esi
cmpl $0x3, %esi
ja 0x34efe
movq %rdx, %r15
leaq 0x12821(%rip), %rax     # 0x476a4
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq %r15, %rdi
callq 0x2efe0
negq %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x2eed4
jmp 0x34f05
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq %r15, %rdi
callq 0x2f04c
negq %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x2eefe
jmp 0x34f05
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq %r15, %rdi
callq 0x2f0d2
fchs
fstpt (%rsp)
movq %r14, %rdi
callq 0x2ef50
fldz
fstp %st(0)
jmp 0x34f05
movq $-0x1, %r14
movq %r14, 0x18(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
fstp %st(0)
jmp 0x34f1a
jmp 0x34f1a
movq %rax, %rbx
movq %r14, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/x86.cpp
// Function: x86::Assembler::getWideStr[abi:cxx11](unsigned long)
string Assembler::getWideStr(size_t size) {
  if (wideMap.find(size) == wideMap.end()) {
    log("IN getWide: ERROR SIZE " + to_string(size));
    return "BadWide";
  }
  return wideMap[size];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, -0x30(%rbp)
movq 0x50(%rsi), %rax
testq %rax, %rax
je 0x36f51
leaq 0x40(%r14), %rdi
leaq 0x48(%r14), %rdx
movq %rdx, %rcx
xorl %esi, %esi
cmpq %r15, 0x20(%rax)
setb %sil
cmovaeq %rax, %rcx
movq 0x10(%rax,%rsi,8), %rax
testq %rax, %rax
jne 0x36f2e
cmpq %rdx, %rcx
je 0x36f51
cmpq %r15, 0x20(%rcx)
jbe 0x36fa4
movl $0x1, %esi
cmpq $0xa, %r15
jb 0x36fd2
movl $0x4, %esi
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x36fcb
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0x36fd0
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0x36fd2
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0x36f6e
addl $-0x3, %esi
jmp 0x36fd2
leaq -0x30(%rbp), %rsi
callq 0x3a768
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xf7ca
jmp 0x3709b
addl $-0x2, %esi
jmp 0x36fd2
decl %esi
movl %esi, %esi
leaq -0x60(%rbp), %r13
movq %r13, -0x10(%r13)
leaq -0x70(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x4360
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
callq 0xefce
leaq 0x10787(%rip), %rcx     # 0x47789
movl $0x17, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4330
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x37038
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x3703f
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq -0x50(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
callq 0x370da
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x37070
callq 0x42b0
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x3707e
callq 0x42b0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x10715(%rip), %rsi     # 0x477a1
leaq 0x10715(%rip), %rdx     # 0x477a8
movq %rbx, %rdi
callq 0xf868
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x370c3
callq 0x42b0
jmp 0x370c3
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x370d1
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop