LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x2fb19
leaq 0x17c4f(%rip), %rcx     # 0x4772c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x2fb19
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x42b0
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x2fb19
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x2faef
callq 0x42b0
jmp 0x2faef
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fb97
movl %esi, %eax
leaq 0x17c02(%rip), %rcx     # 0x47740
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x17ce7(%rip), %rsi     # 0x47835
leaq 0x17cec(%rip), %rdx     # 0x47841
jmp 0x2fba5
leaq 0x17d14(%rip), %rsi     # 0x47872
leaq 0x17d17(%rip), %rdx     # 0x4787c
jmp 0x2fba5
leaq 0x17ce5(%rip), %rsi     # 0x47853
leaq 0x17cf0(%rip), %rdx     # 0x47865
jmp 0x2fba5
leaq 0x17ce8(%rip), %rsi     # 0x47866
leaq 0x17cec(%rip), %rdx     # 0x47871
jmp 0x2fba5
leaq 0x17cb4(%rip), %rsi     # 0x47842
leaq 0x17cbd(%rip), %rdx     # 0x47852
jmp 0x2fba5
leaq 0x1775a(%rip), %rsi     # 0x472f8
leaq 0x1775c(%rip), %rdx     # 0x47301
movq %rbx, %rdi
callq 0xf65c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fc9e
leaq 0x17b7b(%rip), %rcx     # 0x47754
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdx
leaq 0x17c90(%rip), %rsi     # 0x4787d
movq %rbx, %rdi
callq 0xe775
jmp 0x2fcbb
movq 0x8(%rsi), %rax
leaq 0x16f3b(%rip), %rcx     # 0x46b40
leaq 0x16f39(%rip), %rdx     # 0x46b45
cmpb $0x0, (%rax)
cmovneq %rcx, %rdx
leaq 0x17cad(%rip), %rsi     # 0x478c7
jmp 0x2fc5a
movq 0x8(%rsi), %rax
movq (%rax), %rdx
leaq 0x17c75(%rip), %rsi     # 0x4789f
jmp 0x2fc5a
movq 0x8(%rsi), %rax
fldt (%rax)
fstpt (%rsp)
leaq 0x17c78(%rip), %rsi     # 0x478b4
leaq -0x50(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x40c0
jmp 0x2fc68
movq 0x8(%rsi), %rax
movq (%rax), %rdx
leaq 0x17c32(%rip), %rsi     # 0x4788c
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 0x2fcb6
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x17663(%rip), %rsi     # 0x472f8
leaq 0x17665(%rip), %rdx     # 0x47301
jmp 0x2fcb3
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1695b(%rip), %rsi     # 0x46607
leaq 0x1695b(%rip), %rdx     # 0x4660e
movq %rbx, %rdi
callq 0xf65c
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fe44
movl %esi, %eax
leaq 0x17981(%rip), %rcx     # 0x47780
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl %ebx, %esi
jne 0x2fe44
movl %esi, %eax
jmp 0x2fe9c
leal -0x1(%rbx), %eax
cmpl $0x3, %eax
jae 0x2fe44
movl %ebx, %eax
jmp 0x2fe9c
leal -0x1(%rbx), %ecx
movl $0x3, %eax
cmpl $0x3, %ecx
jae 0x2fe44
jmp 0x2fe9c
leal -0x1(%rbx), %eax
cmpl $0x3, %eax
jae 0x2fe44
movl %eax, %eax
leaq 0x1797d(%rip), %rcx     # 0x477bc
movl (%rcx,%rax,4), %eax
jmp 0x2fe9c
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x2fb20
movq (%r14), %r14
leaq -0x50(%rbp), %rdi
movl %ebx, %esi
callq 0x2fb20
leaq -0x40(%rbp), %rbx
movq -0x10(%rbx), %rdx
leaq 0x17a69(%rip), %rdi     # 0x478d6
movq %r14, %rsi
xorl %eax, %eax
callq 0x4070
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x2fe85
callq 0x42b0
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fe97
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 0x2feba
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31f64
leaq 0x18(%r14), %rcx
cmpq %rcx, %rax
jne 0x30223
movq (%r14), %rdi
cmpq 0x8(%r14), %rdi
je 0x30228
callq 0x30230
movq %rax, %r14
jmp 0x301fb
movl 0x40(%rax), %eax
jmp 0x3022a
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d1b0(%rip), %rax     # 0x5d3f0
cmpq 0x2d1b1(%rip), %rax     # 0x5d3f8
jne 0x3024e
callq 0x315d2
movq 0x2d1a3(%rip), %rcx     # 0x5d3f8
movq 0x2d194(%rip), %rdx     # 0x5d3f0
subq %rdx, %rcx
sarq $0x6, %rcx
xorl %eax, %eax
cmpq %rbx, %rcx
cmovaq %rbx, %rax
shlq $0x6, %rax
addq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x302f2
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x32002
addq $0x18, %r12
cmpq %r12, %rax
je 0x3030a
movq (%rbx), %rbx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x27a86
movq (%r14), %rdx
leaq 0x17688(%rip), %rdi     # 0x47952
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
movq (%r14), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x302e5
callq 0x42b0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17c60(%rip), %rdi     # 0x47f59
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 0x2770a
movq %rax, -0x40(%rbp)
movq -0x58(%rbp), %rsi
cmpq -0x50(%rbp), %rsi
je 0x3033c
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, -0x58(%rbp)
jmp 0x30349
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x19282
leaq -0x38(%rbp), %r15
movl $0x3, -0x8(%r15)
leaq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x26102
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3196c
movl -0x40(%rbp), %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
movups 0x10(%rax), %xmm0
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq %rdi, -0x38(%rbp)
movups %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
testq %rdi, %rdi
je 0x303b2
callq 0x42b0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x303c0
callq 0x42b0
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
jne 0x302e0
jmp 0x302e5
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x303ea
callq 0x42b0
jmp 0x303ea
jmp 0x303e7
movq %rax, %rbx
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x303f8
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30478
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x32002
addq $0x18, %r12
cmpq %r12, %rax
je 0x30490
movq (%rbx), %rbx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2ec84
movq (%r14), %rdx
leaq 0x17588(%rip), %rdi     # 0x479d8
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
movq (%r14), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x3046b
callq 0x42b0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17b37(%rip), %rdi     # 0x47fb6
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 0x2f138
movq %r12, -0x40(%rbp)
movq -0x58(%rbp), %rsi
cmpq -0x50(%rbp), %rsi
je 0x304d2
movq %r12, (%rsi)
addq $0x8, %rsi
movq %rsi, -0x58(%rbp)
jmp 0x304df
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x19282
leaq -0x38(%rbp), %r15
movl $0x2, -0x8(%r15)
leaq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x26102
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3196c
movl -0x40(%rbp), %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
movups 0x10(%rax), %xmm0
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq %rdi, -0x38(%rbp)
movups %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
testq %rdi, %rdi
je 0x30548
callq 0x42b0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x30556
callq 0x42b0
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
jne 0x30466
jmp 0x3046b
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
jne 0x3057e
jmp 0x30588
jmp 0x30585
movq %rax, %rbx
movq %r12, %rdi
callq 0x42b0
jmp 0x30588
movq %rax, %rbx
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x30596
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31f64
leaq 0x18(%r15), %rcx
cmpq %rcx, %rax
jne 0x30e50
movq (%r15), %rdi
cmpq 0x8(%r15), %rdi
je 0x30e7d
callq 0x30230
movq %rax, %r15
jmp 0x30e28
cmpl $0x2, 0x40(%rax)
jne 0x30ecb
movq 0x48(%rax), %rcx
cmpq 0x50(%rax), %rcx
je 0x30f16
movq (%rcx), %rsi
movq %r14, %rdi
callq 0x2f138
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16ebd(%rip), %rsi     # 0x47d41
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0xe775
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
movq %rax, %rdi
movl $0x7, %esi
movq %r15, %rdx
callq 0x33d12
leaq 0x2aeb9(%rip), %rsi     # 0x5bd70
leaq -0x22b04(%rip), %rdx    # 0xe3ba
movq %r14, %rdi
callq 0x4540
jmp 0x30f5f
leaq 0x16e6f(%rip), %rsi     # 0x47d41
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0xe775
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
movq %rax, %rdi
movl $0x8, %esi
movq %r15, %rdx
callq 0x33d12
leaq 0x2ae6b(%rip), %rsi     # 0x5bd70
leaq -0x22b52(%rip), %rdx    # 0xe3ba
movq %r14, %rdi
callq 0x4540
jmp 0x30f5f
leaq 0x16e24(%rip), %rsi     # 0x47d41
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0xe775
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
movq %rax, %rdi
movl $0xa, %esi
movq %r15, %rdx
callq 0x33d12
leaq 0x2ae20(%rip), %rsi     # 0x5bd70
leaq -0x22b9d(%rip), %rdx    # 0xe3ba
movq %r14, %rdi
callq 0x4540
jmp 0x30f67
jmp 0x30f6c
jmp 0x30f67
jmp 0x30f6c
movq %rax, %rbx
jmp 0x30f77
movq %rax, %rbx
movq %r14, %rdi
callq 0x4250
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30f89
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c283(%rip), %rdx     # 0x5d3f0
movq 0x2c284(%rip), %rcx     # 0x5d3f8
movq %rcx, -0x40(%rbp)
cmpq %rcx, %rdx
je 0x3122d
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 0x3121b
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x28(%rax)
je 0x3120c
movq -0x30(%rbp), %rax
cmpl $0x1, 0x40(%rax)
jne 0x3120c
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rbx
movq 0x50(%rax), %r15
cmpq %r15, %rbx
je 0x3120c
movq (%rbx), %r12
movq (%rbx), %rax
movq %r13, -0x70(%rbp)
movq 0x38(%rax), %rsi
movq 0x40(%rax), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xf5c2
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x319ec
movq %rax, %rdi
movq %r12, %rsi
callq 0x31a6c
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x31206
callq 0x42b0
addq $0x8, %rbx
jmp 0x311bf
movq -0x30(%rbp), %rdi
callq 0x4350
cmpq -0x50(%rbp), %rax
jne 0x3119e
movq -0x48(%rbp), %rdx
addq $0x40, %rdx
cmpq -0x40(%rbp), %rdx
jne 0x31189
movq -0x38(%rbp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x31256
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x31256
callq 0x42b0
movq -0x38(%rbp), %rdi
callq 0x31e0e
movq %r14, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r14
movl %r15d, (%r14)
leaq 0x2be00(%rip), %rdi     # 0x5d3f0
movq %r14, %rsi
callq 0x31b28
movq 0x2bdf1(%rip), %rbx     # 0x5d3f0
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movl %r15d, (%r14)
movq -0x48(%rbp), %rsi
testq %rsi, %rsi
je 0x3162b
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x31638
leaq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x2e522
leaq -0x30(%rbp), %r14
movl $0x0, -0x8(%r14)
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x26102
addq $0x10, %rbx
leaq -0x60(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x31b70
movl -0x38(%rbp), %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
movups 0x10(%rax), %xmm0
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq %rdi, -0x30(%rbp)
movups %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
testq %rdi, %rdi
je 0x316ba
callq 0x42b0
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x316c8
callq 0x42b0
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x316d6
callq 0x42b0
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x316e4
callq 0x42b0
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31712
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x31702
callq 0x42b0
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x31715
callq 0x42b0
jmp 0x31715
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x31723
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, -0x10(%rbp)
movq 0x2bcb3(%rip), %rax     # 0x5d3f0
cmpq 0x2bcb4(%rip), %rax     # 0x5d3f8
jne 0x3174b
callq 0x315d2
movq -0x10(%rbp), %rsi
movq 0x2bca2(%rip), %rax     # 0x5d3f8
subq 0x2bc93(%rip), %rax     # 0x5d3f0
sarq $0x6, %rax
cmpq %rax, %rsi
jae 0x3179c
leaq 0x2bc83(%rip), %rdi     # 0x5d3f0
leaq -0x10(%rbp), %rsi
callq 0x31bf0
movq 0x2bc7b(%rip), %rbx     # 0x5d3f8
movq 0x2bc6c(%rip), %rax     # 0x5d3f0
subq %rax, %rbx
sarq $0x6, %rbx
decq %rbx
movq %rbx, %rcx
shlq $0x6, %rcx
movq %rbx, 0x8(%rax,%rcx)
jmp 0x317ac
leaq 0x16613(%rip), %rdi     # 0x47db6
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4070
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31883
movl 0x40(%r14), %eax
cmpl $0x2, %eax
je 0x31832
cmpl $0x1, %eax
jne 0x3186f
movq 0x48(%r14), %r13
movq 0x50(%r14), %rbx
cmpq %rbx, %r13
je 0x3186f
movq (%r13), %r15
testq %r15, %r15
je 0x3182c
leaq 0x58(%r15), %rdi
callq 0xe800
movq 0x38(%r15), %rdi
leaq 0x48(%r15), %rax
cmpq %rax, %rdi
je 0x3181c
callq 0x42b0
movq %r15, %rdi
callq 0x28344
movq %r15, %rdi
callq 0x42b0
addq $0x8, %r13
jmp 0x317f3
movq 0x48(%r14), %rbx
movq 0x50(%r14), %r13
cmpq %r13, %rbx
je 0x3186f
movq (%rbx), %r15
testq %r15, %r15
je 0x31869
movq 0x38(%r15), %rdi
leaq 0x48(%r15), %rax
cmpq %rax, %rdi
je 0x31859
callq 0x42b0
movq %r15, %rdi
callq 0x28344
movq %r15, %rdi
callq 0x42b0
addq $0x8, %rbx
jmp 0x3183a
movq %r14, %rdi
callq 0x4230
movq %rax, %r14
cmpq %r12, %rax
jne 0x317d9
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31c84
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31904
cmpq $0x0, 0x28(%r15)
je 0x318f4
leaq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x31c38
movq %r15, %rdi
callq 0x4350
movq %rax, %r15
cmpq %r14, %rax
jne 0x318e1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xee68
movq %r14, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 -0x60(%rbp), %r14
movq %r14, %rdi
callq 0x33b46
movq 0x18(%r14), %r14
leaq -0x58(%rbp), %rax
cmpq %rax, %r14
je 0x33305
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rcx
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movl $0x2, %r12d
leaq 0x14e86(%rip), %rdi     # 0x4810e
cmpq %rcx, %rdx
jbe 0x332a7
movq 0x20(%r14), %r15
movq (%rax,%rcx,8), %rcx
movl $0x3, %r12d
leaq 0x14ea3(%rip), %rdi     # 0x48145
cmpq %rcx, %r15
jne 0x332cd
callq 0x4480
cmpl $0x3, %r12d
je 0x332b7
testl %r12d, %r12d
jne 0x33305
movq %r14, %rdi
callq 0x4350
movq %rax, %r14
leaq -0x58(%rbp), %rax
cmpq %rax, %r14
jne 0x33268
jmp 0x33305
cmpq %r15, %rcx
movl -0x2c(%rbp), %ecx
adcl $0x0, %ecx
movl %ecx, -0x2c(%rbp)
movslq %ecx, %r13
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
callq 0x33364
cmpq %r15, %rax
je 0x332ac
movq 0x48(%rbx), %rax
movq (%rax,%r13,8), %rdx
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x17c42
jmp 0x332ac
movq 0x90(%rbx), %r14
leaq 0x80(%rbx), %r15
cmpq %r15, %r14
je 0x33336
movq 0x20(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x17c42
movq %r14, %rdi
callq 0x4350
movq %rax, %r14
cmpq %r15, %rax
jne 0x33318
leaq -0x60(%rbp), %rdi
callq 0x13eae
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33350
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x13eae
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdi, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17db2
cmpq $-0x1, %rax
je 0x33397
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17db2
cmpq %rbx, %rax
movq %rax, %rbx
jne 0x33371
jmp 0x3339a
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14db1(%rip), %rdi     # 0x48183
xorl %eax, %eax
callq 0x4070
movq 0x60(%rbx), %rax
cmpq %rax, 0x68(%rbx)
je 0x33470
leaq 0x13aa6(%rip), %r15     # 0x46e94
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 0x14d86(%rip), %rdi     # 0x48197
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 0x33441
movq (%r13), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x4070
addq $0x8, %r13
jmp 0x33428
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 0x333f1
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_O1/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 0x14d0a(%rip), %rdi     # 0x481b4
xorl %eax, %eax
callq 0x4070
movq 0x90(%rbx), %r14
leaq 0x80(%rbx), %r15
cmpq %r15, %r14
je 0x33511
leaq 0x14cfa(%rip), %r12     # 0x481c5
movq 0x20(%r14), %r13
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x17aac
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 0x33501
callq 0x42b0
movq %r14, %rdi
callq 0x4350
movq %rax, %r14
cmpq %r15, %rax
jne 0x334cb
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_O1/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 0x14c7c(%rip), %rdi     # 0x481cd
xorl %eax, %eax
callq 0x4070
movq 0x48(%rbx), %r13
movq 0x50(%rbx), %r14
cmpq %r14, %r13
je 0x335ab
leaq 0x14c59(%rip), %r15     # 0x481c5
movq (%r13), %r12
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x17aac
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 0x335a2
callq 0x42b0
addq $0x8, %r13
cmpq %r14, %r13
jne 0x3356c
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_O1/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 0x144ad(%rip), %rsi     # 0x48251
leaq 0x144be(%rip), %rdx     # 0x48269
movq %rdi, -0x30(%rbp)
callq 0xf65c
movl 0x8(%r15), %esi
leaq -0x70(%rbp), %rdi
movq %rbx, -0x78(%rbp)
callq 0x33f8c
leaq 0x149b9(%rip), %rsi     # 0x48785
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 0x33df9
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x33dff
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 0x33e35
callq 0x42b0
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x33e47
callq 0x42b0
movq 0x10(%r15), %r14
movq 0x18(%r15), %r15
cmpq %r15, %r14
je 0x33efb
leaq -0x70(%rbp), %r12
leaq 0x14922(%rip), %r13     # 0x48785
movq %r12, %rdi
leaq 0x12837(%rip), %rsi     # 0x466a4
movq %r14, %rdx
callq 0xe775
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 0x33ea0
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x33ea6
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 0x33edc
callq 0x42b0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x33eee
callq 0x42b0
addq $0x20, %r14
cmpq %r15, %r14
jne 0x33e63
leaq 0x1337e(%rip), %rsi     # 0x47280
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 0x33f44
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x33f38
callq 0x42b0
jmp 0x33f38
movq %rax, %r14
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
jmp 0x33f67
jmp 0x33f44
movq %rax, %r14
jmp 0x33f71
movq %rax, %r14
jmp 0x33f5f
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x33f5f
callq 0x42b0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x33f71
callq 0x42b0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq -0x78(%rbp), %rdi
je 0x33f83
callq 0x42b0
movq %r14, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33d82
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x33d82
movq -0x30(%rbp), %rdi
incq %rdi
callq 0x4030
movq %rax, %rbx
leaq -0x28(%rbp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x341b9
callq 0x42b0
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x33d82
movq -0x38(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42a0
cmpq %r15, %r14
je 0x341e1
movq %r14, %rdi
callq 0x42b0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x341f3
callq 0x42b0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0xe590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3491d
movq %rcx, %r15
movq %rdx, %r12
leaq 0x13d82(%rip), %rax     # 0x485fc
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq %r12, %rdi
callq 0x2f8a4
movq %rax, %r12
movq %r15, %rdi
callq 0x2f8a4
addq %r12, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x2f798
jmp 0x34924
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq %r12, %rdi
callq 0x2f910
movq %rax, %r12
movq %r15, %rdi
callq 0x2f910
addq %r12, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x2f7c2
jmp 0x34924
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq %r12, %rdi
callq 0x2f996
fstpt -0x2c(%rbp)
fldz
fstp %st(0)
movq %r15, %rdi
callq 0x2f996
fldt -0x2c(%rbp)
faddp %st, %st(1)
fstpt (%rsp)
movq %r14, %rdi
callq 0x2f814
fldz
fstp %st(0)
jmp 0x34924
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 0x3493b
jmp 0x3493b
movq %rax, %rbx
movq %r14, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35822
movq %rdx, %r15
leaq 0x12efd(%rip), %rax     # 0x486a4
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq %r15, %rdi
callq 0x2f8a4
negq %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x2f798
jmp 0x35829
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq %r15, %rdi
callq 0x2f910
negq %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x2f7c2
jmp 0x35829
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq %r15, %rdi
callq 0x2f996
fchs
fstpt (%rsp)
movq %r14, %rdi
callq 0x2f814
fldz
fstp %st(0)
jmp 0x35829
movq $-0x1, %r14
movq %r14, 0x18(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
fstp %st(0)
jmp 0x3583e
jmp 0x3583e
movq %rax, %rbx
movq %r14, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rdx
leaq 0x48(%rsi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x37899
movq %rax, %rcx
xorl %esi, %esi
cmpq %r15, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x37881
movq %rax, %rdx
cmpq %rax, %rcx
je 0x378ac
cmpq %r15, 0x20(%rcx)
cmovaq %rax, %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
je 0x378df
addq $0x40, %r14
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x3b198
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xf5c2
jmp 0x37a02
movl $0x1, %esi
cmpq $0xa, %r15
jb 0x37939
movl $0x4, %esi
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x37932
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0x37937
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0x37939
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0x378fc
addl $-0x3, %esi
jmp 0x37939
addl $-0x2, %esi
jmp 0x37939
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 0xede8
leaq 0x10e20(%rip), %rcx     # 0x48789
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 0x3799f
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x379a6
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 0x37a40
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x379d7
callq 0x42b0
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x379e5
callq 0x42b0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x10dae(%rip), %rsi     # 0x487a1
leaq 0x10dae(%rip), %rdx     # 0x487a8
movq %rbx, %rdi
callq 0xf65c
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 0x37a2a
callq 0x42b0
jmp 0x37a2a
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x37a38
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/x86.cpp
// Function: x86::Assembler::quaASSIGN(std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void Assembler::quaASSIGN(const Qua &qua) {
  // (:=,0,_,[esp+0])
  const string &dist = get<3>(qua);
  const string &src = get<1>(qua);
  if (dist == "eax" || src == "eax") {
    mov(dist, src);
  } else {
    mov("eax", src);
    mov(dist, "eax");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xfe0e(%rip), %rsi      # 0x487a9
movq %r14, %rdi
callq 0x40f0
testl %eax, %eax
je 0x38a95
leaq 0x40(%r14), %rdi
leaq 0xfdf3(%rip), %rsi      # 0x487a9
callq 0x40f0
testl %eax, %eax
je 0x38a95
leaq -0x90(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xfdd4(%rip), %rsi      # 0x487a9
leaq 0xfdd0(%rip), %rdx      # 0x487ac
leaq -0xa0(%rbp), %rdi
callq 0xf65c
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0xf5c2
leaq -0xa0(%rbp), %rsi
leaq -0x80(%rbp), %rdx
movq %rbx, %rdi
callq 0x3b202
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x38a26
callq 0x42b0
movq -0xa0(%rbp), %rdi
cmpq %r15, %rdi
je 0x38a37
callq 0x42b0
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0xf5c2
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xfd48(%rip), %rsi      # 0x487a9
leaq 0xfd44(%rip), %rdx      # 0x487ac
leaq -0x40(%rbp), %rdi
callq 0xf65c
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x3b202
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x38a8f
callq 0x42b0
movq -0x60(%rbp), %rdi
jmp 0x38b07
leaq -0xd0(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0xe0(%rbp), %rdi
callq 0xf5c2
leaq -0xb0(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
leaq -0xc0(%rbp), %rdi
callq 0xf5c2
leaq -0xe0(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
movq %rbx, %rdi
callq 0x3b202
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x38b00
callq 0x42b0
movq -0xe0(%rbp), %rdi
cmpq %r15, %rdi
je 0x38b11
callq 0x42b0
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x38b37
callq 0x42b0
jmp 0x38b37
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0x38b7c
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x38b53
callq 0x42b0
jmp 0x38b53
movq %rax, %rbx
movq -0xa0(%rbp), %rdi
jmp 0x38b7c
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x38b75
callq 0x42b0
jmp 0x38b75
movq %rax, %rbx
movq -0xe0(%rbp), %rdi
cmpq %r15, %rdi
je 0x38b86
callq 0x42b0
movq %rbx, %rdi
callq 0x4560