LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::get_false_list() const
const vector<size_t> &ParseNode::get_false_list() const {
    // 需求特殊性: 如果没有则先set为空, 再返回之
    if (!(keys & K_FALSE_LIST)) {
        ((ParseNode *) this)->set_false_list(vector<size_t>());
    }
    return get_field<vector<size_t>>(K_FALSE_LIST);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testb $0x1, 0xa(%rdi)
jne 0x1d009
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %rbx, %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %ecx, %ecx
callq 0x1f918
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1d009
callq 0x42b0
movq %rbx, %rdi
movl $0x10000, %esi          # imm = 0x10000
callq 0x22aa8
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1d02e
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::get_next_list() const
const vector<size_t> &ParseNode::get_next_list() const {
    // 需求特殊性: 如果没有则先set为空, 再返回之
    if (!(keys & K_NEXT_LIST)) {
        ((ParseNode *) this)->set_next_list(vector<size_t>());
    }
    return get_field<vector<size_t> >(K_NEXT_LIST);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testb $0x8, 0xa(%rdi)
jne 0x1d09f
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %rbx, %rdi
movl $0x80000, %esi          # imm = 0x80000
xorl %ecx, %ecx
callq 0x1f918
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1d09f
callq 0x42b0
movq %rbx, %rdi
movl $0x80000, %esi          # imm = 0x80000
callq 0x22aa8
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1d0c4
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::add_expression_list(ParseExpression const&)
void ParseNode::add_expression_list(const ParseExpression &expr) {
    if (has_key(K_EXPRESSION_LIST)) {
        auto &list = (vector<size_t> &) get_expression_list();
        list.emplace_back(expr.get_id());
    } else {
        vector<size_t> list;
        list.emplace_back(expr.get_id());
        set_field<vector<size_t> >(K_EXPRESSION_LIST, list);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testb $-0x80, 0xa(%rdi)
jne 0x1d5f3
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq %r14, %rdi
callq 0x2cfa2
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rsi
cmpq -0x20(%rbp), %rsi
je 0x1d634
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x1d641
movq %rbx, %rdi
movl $0x800000, %esi         # imm = 0x800000
callq 0x22aa8
movq %rax, %rbx
movq %r14, %rdi
callq 0x2cfa2
movq %rax, -0x30(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1d626
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1d662
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x19282
jmp 0x1d662
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x19282
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movl $0x800000, %esi         # imm = 0x800000
xorl %ecx, %ecx
callq 0x1f918
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1d662
callq 0x42b0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1d66d
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1d67e
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::add_array_size(unsigned long)
void ParseNode::add_array_size(size_t array_size) {
    if (has_key(K_ARRAY_SIZE)) {
        auto &list = (vector<size_t> &) get_array_size();
        list.emplace_back(array_size);
    } else {
        vector<size_t> list;
        list.emplace_back(array_size);
        set_field<vector<size_t> >(K_ARRAY_SIZE, list);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, -0x10(%rbp)
testb $-0x80, 0x8(%rdi)
jne 0x1d6c1
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rax
testq %rax, %rax
je 0x1d6e9
movq %rsi, (%rax)
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x1d6f9
movq %rbx, %rdi
movl $0x80, %esi
callq 0x22aa8
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x1d71c
movq -0x10(%rbp), %rcx
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rax)
jmp 0x1d728
leaq -0x30(%rbp), %rdi
leaq -0x10(%rbp), %rdx
movq %rax, %rsi
callq 0x266ec
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movl $0x80, %esi
xorl %ecx, %ecx
callq 0x1f918
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1d728
callq 0x42b0
jmp 0x1d728
leaq -0x10(%rbp), %rdx
movq %rax, %rdi
callq 0x266ec
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1d740
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::add_init_declarator(std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ParseExpression, unsigned long, std::vector<unsigned long, std::allocator<unsigned long>>, unsigned long> const&)
void ParseNode::add_init_declarator(const InitDeclarator &init_declarator) {
    if (has_key(K_INIT_DECLARATORS)) {
        auto &list = (vector<InitDeclarator> &) get_init_declarators();
        list.emplace_back(init_declarator);
    } else {
        vector<InitDeclarator> list;
        list.emplace_back(init_declarator);
        set_field<vector<InitDeclarator> >(K_INIT_DECLARATORS, list);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, 0x9(%rdi)
jne 0x1d79e
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %r14, %rsi
callq 0x201d2
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movl $0x100, %esi            # imm = 0x100
xorl %ecx, %ecx
callq 0x2020e
leaq -0x30(%rbp), %rdi
callq 0x13b0e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x23742
movq %rax, %rdi
movq %r14, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x201d2
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x13b0e
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::assign(ParseType&, ParseType const&)
void ParseType::assign(ParseType &type, const ParseType &from_type) {
    delete type.fields;
    if (from_type.fields) {
        type.fields = new map<string, size_t>(*from_type.fields);
    } else {
        type.fields = nullptr;
    }
    type.lower_type = from_type.lower_type;
    type.specifier = from_type.specifier;
    type.base_type = from_type.base_type;
    type.type_size = from_type.type_size;
    type.pointer_level = from_type.pointer_level;
    type.array_size = from_type.array_size;
    type.type_id = from_type.type_id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x2755a
movq %r15, %rdi
callq 0x13e44
movq %r15, %rdi
callq 0x42b0
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x2757d
movl $0x30, %edi
callq 0x42e0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x2977a
jmp 0x27580
xorl %r15d, %r15d
movq %r15, 0x10(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movl 0x4(%r14), %eax
movl %eax, 0x4(%rbx)
movl (%r14), %eax
movl %eax, (%rbx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::get_pointer(ParseType const&, unsigned long)
ParseType ParseType::get_pointer(const ParseType &type, size_t ptr_level) {
    if (ptr_level == 0) {
        printf("ParseType::get_pointer(const ParseType &type, size_t ptr_level): 警告: 获取类型%s的0级指针\n",
               type.get_info().c_str());
        return type;
    }
    if (type.pointer_level == 0) {
        return ParseType(T_UNKNOWN, get_type_id(type), nullptr, sizeof(void *), ptr_level, 0);
    } else {
        auto res = ParseType(type);
        res.type_id = (size_t) -1;
        res.pointer_level += ptr_level;
        return res;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x279e2
movq %rdx, %r15
leaq 0x8(%rbx), %r12
cmpq $0x0, 0x28(%r14)
je 0x27a35
movl $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r12)
movups %xmm0, 0x10(%r12)
movups %xmm0, (%r12)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27530
movq $-0x1, 0x18(%rbx)
addq %r15, 0x28(%rbx)
jmp 0x27a76
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x27a86
movq (%r15), %rsi
leaq 0x1f4de(%rip), %rdi     # 0x46ed9
xorl %eax, %eax
callq 0x4070
movq (%r15), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x27a13
callq 0x42b0
movl $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27530
jmp 0x27a76
movq %r14, %rdi
callq 0x27f08
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movups %xmm0, 0x10(%r12)
movups %xmm0, 0x20(%r12)
xorl %ecx, %ecx
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
movq $0x8, 0x20(%rbx)
movq %r15, 0x28(%rbx)
movq %rcx, 0x30(%rbx)
movq $-0x1, 0x18(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::get_type_id(ParseType const&)
size_t ParseType::get_type_id(const ParseType &type) {
    if (id2type.empty()) {
        // 没有经过初始化, 进行初始化
        init();
    }
    if (type.type_id == (size_t) -1) {
        auto iter = type2id.find(type);
        if (iter == type2id.end()) {
            ((ParseType &) type).type_id = id2type.size();
            type2id[type] = type.type_id;
            id2type.emplace_back(type);
            id2info.emplace_back(type.get_info());
            return type.type_id;
        }
        return ((ParseType &) type).type_id = iter->second;
    }
    return type.type_id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x353d9(%rip), %rax     # 0x5d2f8
cmpq 0x353da(%rip), %rax     # 0x5d300
jne 0x27f2d
callq 0x286be
movq 0x18(%rbx), %rax
cmpq $-0x1, %rax
jne 0x27fdc
leaq 0x35386(%rip), %rdi     # 0x5d2c8
movq %rbx, %rsi
callq 0x2a5ca
leaq 0x3537f(%rip), %rcx     # 0x5d2d0
cmpq %rcx, %rax
je 0x27f60
movq 0x58(%rax), %rax
movq %rax, 0x18(%rbx)
jmp 0x27fdc
leaq 0x35391(%rip), %r14     # 0x5d2f8
movq 0x35392(%rip), %rax     # 0x5d300
subq 0x35383(%rip), %rax     # 0x5d2f8
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %r15 # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %r15
movq %r15, 0x18(%rbx)
leaq 0x35336(%rip), %rdi     # 0x5d2c8
movq %rbx, %rsi
callq 0x29506
movq %r15, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2959a
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27a86
leaq 0x35352(%rip), %rdi     # 0x5d310
movq %r14, %rsi
callq 0x153ae
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27fd8
callq 0x42b0
movq 0x18(%rbx), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27ffc
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::get_type(unsigned long)
const ParseType &ParseType::get_type(size_t type_id) {
    if (id2type.empty()) {
        // 没有经过初始化, 进行初始化
        init();
    }
    if (type_id >= id2type.size()) {
        printf("ParseType &ParseType::get_type(size_t type_id): 警告: 试图获取不存在的类型, id:%zu\n", type_id);
        return id2type[T_UNKNOWN];
    }
    return id2type[type_id];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x352e4(%rip), %rax     # 0x5d2f8
cmpq 0x352e5(%rip), %rax     # 0x5d300
jne 0x28022
callq 0x286be
movq 0x352d7(%rip), %rcx     # 0x5d300
movq 0x352c8(%rip), %rax     # 0x5d2f8
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rcx, %rdx
cmpq %rbx, %rdx
jbe 0x28053
imulq $0x38, %rbx, %rcx
addq %rcx, %rax
jmp 0x2806b
leaq 0x1eee5(%rip), %rdi     # 0x46f3f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
movq 0x3528d(%rip), %rax     # 0x5d2f8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::ParseType()
ParseType::ParseType() {
    base_type = T_UNKNOWN;
    array_size = pointer_level = type_size = 0;
    lower_type = 0;
    type_id = (size_t) -1;
    fields = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x28(%rdi)
movq $-0x1, 0x18(%rdi)
movq $0x0, 0x10(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::ParseType(BaseType, unsigned long, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, unsigned long>>>*, unsigned long, unsigned long, unsigned long, int)
ParseType::ParseType(BaseType bt, size_t low_t, map<string, size_t> *fs, size_t ts, size_t ptr_lv, size_t arr_size, int spe) {
    base_type = bt;
    lower_type = low_t;
    fields = fs;
    specifier = spe;
    type_size = ts;
    pointer_level = ptr_lv;
    array_size = arr_size;
    type_id = (size_t) -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movl 0x18(%rbp), %r10d
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movl %esi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movl %r10d, 0x4(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq $-0x1, 0x18(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::field(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
ParseType ParseType::field(const string &key) const {
    if (fields) {
        auto iter = fields->find(key);
        if (iter == fields->end()) {
            return ParseType();
        }
        return id2type[iter->second];
    }
    return ParseType();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
je 0x28d5c
movq %rsi, %r14
movq %rdx, %rsi
callq 0x19e18
movq 0x10(%r14), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x28d5c
imulq $0x38, 0x40(%rax), %rsi
addq 0x345bb(%rip), %rsi     # 0x5d2f8
movl $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movq %rbx, %rdi
callq 0x27530
jmp 0x28d81
movl $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x28(%rbx)
movq $-0x1, 0x18(%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::get_specifier() const
size_t ParseType::get_specifier() const {
    if (base_type == T_UNKNOWN) {
        printf("ParseType::get_specifier(): 警告: 试图获取非基础类型Type-%zu的标识符\n", get_id());
        return 0;
    }
    return lower_type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x28d9e
movq 0x8(%rbx), %rbx
jmp 0x28dc7
movq 0x18(%rbx), %rsi
cmpq $-0x1, %rsi
jne 0x28db7
movq %rbx, %rdi
callq 0x27f08
movq %rax, %rsi
movq %rax, 0x18(%rbx)
leaq 0x1e1ea(%rip), %rdi     # 0x46fa8
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4070
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::cmp_wider_type(unsigned long, unsigned long)
bool ParseType::cmp_wider_type(size_t t1_id, size_t t2_id) {
    if (t1_id <= T_BASE && t2_id <= T_BASE) {
        return t1_id >= t2_id;
    } else {
        const ParseType &t1 = ParseType::get_type(t1_id),
                &t2 = ParseType::get_type(t2_id);
        if (t1.base_type == t2.base_type && t1.base_type != T_UNKNOWN) {
            // 是基础类型的特殊声明 long unsigned等
            return t1.specifier >= t2.specifier;
        } else {
            return t1_id >= t2_id;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0xa, %rdi
setae %al
cmpq $0xa, %rsi
setae %cl
orb %al, %cl
jne 0x29388
cmpq %rbx, %r14
setae %al
jmp 0x293b0
movq %r14, %rdi
callq 0x28004
movq %rax, %r15
movq %rbx, %rdi
callq 0x28004
movl (%r15), %ecx
testl %ecx, %ecx
je 0x29380
cmpl (%rax), %ecx
jne 0x29380
movl 0x4(%r15), %ecx
cmpl 0x4(%rax), %ecx
setge %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::update(ParseExpression const&)
void ParseExpression::update(const ParseExpression &expr) {
    if (id2expr.empty()) {
        init();
    }
    auto it = expr2id.find(expr);
    if (it == expr2id.end()) {
        expr2id[expr] = id2expr.size();
        ((ParseExpression &) expr).expr_id = id2expr.size();
        id2expr.emplace_back(expr);
        id2address.emplace_back(0);
        expr_call_back(id2expr[id2expr.size() - 1]);
    } else {
        ((ParseExpression &) expr).expr_id = it->second;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x31c07(%rip), %rax     # 0x5d3c0
cmpq 0x31c08(%rip), %rax     # 0x5d3c8
jne 0x2b7c7
callq 0x2c206
leaq 0x31bc2(%rip), %rdi     # 0x5d390
movq %rbx, %rsi
callq 0x2e8f4
leaq 0x31bbb(%rip), %rcx     # 0x5d398
cmpq %rcx, %rax
je 0x2b7ef
movq 0x50(%rax), %rax
movq %rax, 0x10(%rbx)
jmp 0x2b898
movq 0x31bd2(%rip), %r15     # 0x5d3c8
subq 0x31bc3(%rip), %r15     # 0x5d3c0
leaq 0x31bbc(%rip), %r14     # 0x5d3c0
sarq $0x4, %r15
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %r15
leaq 0x31b73(%rip), %rdi     # 0x5d390
movq %rbx, %rsi
callq 0x2e156
movq %r15, (%rax)
movq 0x31b99(%rip), %rax     # 0x5d3c8
subq 0x31b8a(%rip), %rax     # 0x5d3c0
sarq $0x4, %rax
imulq %r12, %rax
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2e1ea
movl $0x0, -0x24(%rbp)
movq 0x31b85(%rip), %rsi     # 0x5d3e0
cmpq 0x31b86(%rip), %rsi     # 0x5d3e8
je 0x2b878
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x31b6a(%rip)     # 0x5d3e0
jmp 0x2b888
leaq 0x31b59(%rip), %rdi     # 0x5d3d8
leaq -0x24(%rbp), %rdx
callq 0x2e522
movq 0x31b39(%rip), %rdi     # 0x5d3c8
addq $-0x30, %rdi
callq 0x5ad5
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::get_expression(unsigned long)
const ParseExpression &ParseExpression::get_expression(size_t expr_id) {
    if (id2expr.empty()) {
        init();
    }
    if (expr_id >= id2expr.size()) {
        printf("ParseExpression::expression(size_t expr_id): 警告:试图获取未定义的表达式ID:%zu\n",
               expr_id);
        return id2expr[0];
    }
    return id2expr[expr_id];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x31b0a(%rip), %rax     # 0x5d3c0
cmpq 0x31b0b(%rip), %rax     # 0x5d3c8
jne 0x2b8c4
callq 0x2c206
movq 0x31afd(%rip), %rcx     # 0x5d3c8
movq 0x31aee(%rip), %rax     # 0x5d3c0
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %rbx, %rdx
jbe 0x2b8f9
leaq (%rbx,%rbx,2), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
jmp 0x2b911
leaq 0x1ba42(%rip), %rdi     # 0x47342
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
movq 0x31aaf(%rip), %rax     # 0x5d3c0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::is_const() const
bool ParseExpression::is_const() const {
    if (expr_type == E_CONST) {
        return true;
    }
    if (const_value == (size_t) -1) {
        return false;
    }
    if (!const_value) {
        ((ParseExpression *) this)->calculate_const();
    }
    return const_value != (size_t) -1;
}

// Assembly:
movb $0x1, %al
cmpl $0x3, 0x28(%rdi)
je 0x2bbca
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq $-0x1, %rax
je 0x2bbc2
testq %rax, %rax
jne 0x2bbb8
movq %rbx, %rdi
callq 0x343a4
cmpq $-0x1, 0x18(%rbx)
setne %al
jmp 0x2bbc4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::ParseExpression()
ParseExpression::ParseExpression() {
    ret_type_id = (size_t) -1;
    child[0] = child[1] = expr_id = 0;
    const_value = 0;
    expr_type = E_UNDEFINED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $-0x1, 0x20(%rdi)
movl $0x0, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::ParseExpression(ParseConstant const&)
ParseExpression::ParseExpression(const ParseConstant &constant) {
    expr_type = E_CONST;
    child[0] = (size_t)
            new ParseConstant(constant);
    const_value = child[0];
    ret_type_id = ParseType(constant).get_id();
    update(*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x3, 0x28(%rdi)
movl $0x10, %edi
callq 0x42e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2f6c6
movq %r15, (%rbx)
movq %r15, 0x18(%rbx)
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2772e
movq %r15, %rdi
callq 0x2770a
movq %rax, 0x20(%rbx)
leaq -0x50(%rbp), %rdi
callq 0x28344
movq %rbx, %rdi
callq 0x2b7a0
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x28344
jmp 0x2bf73
movq %rax, %rbx
movq %r15, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::assign(ParseExpression&, ParseExpression const&)
void ParseExpression::assign(ParseExpression &expr, const ParseExpression &from_expr) {
    expr.expr_id = from_expr.expr_id;
    expr.ret_type_id = from_expr.ret_type_id;
    if (from_expr.is_const()) {
        expr.const_value = (size_t)
                new ParseConstant(*(ParseConstant *) from_expr.const_value);
    } else {
        expr.const_value = (size_t) -1;
    }
    switch (expr.expr_type = from_expr.expr_type) {
        case E_UNDEFINED:
            break;
        case E_ADD:
        case E_SUB:
        case E_MUL:
        case E_DIV:
        case E_MOD:
        case E_POW:
        case E_LOGIC_OR:
        case E_LOGIC_AND:
        case E_G:
        case E_GE:
        case E_EQUAL:
        case E_NE:
        case E_L:
        case E_LE:
        case E_GET_ITEM:
            expr.child[0] = from_expr.child[0];
            expr.child[1] = from_expr.child[1];
            break;
        case E_ADR:
        case E_PTR:
        case E_NEG:
        case E_POS:
        case E_BIT_NOT:
        case E_NOT:
            expr.child[0] = from_expr.child[0];
            break;
        case E_VAR:
            expr.child[0] = (size_t)
                    new ParseVariable(*(ParseVariable *) from_expr.child[0]);
            break;
        case E_CONST:
            expr.child[0] = (size_t)
                    new ParseConstant(*(ParseConstant *) from_expr.child[0]);
            break;
        case E_ASSIGN:
            expr.child[0] = from_expr.child[0];
            expr.child[1] = from_expr.child[1];
            break;
        case E_FUN:
            expr.child[0] = (size_t) new DecFuncPtrList(*(DecFuncPtrList *)from_expr.child[0]);
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rdi)
movq %rsi, %rdi
callq 0x2bb90
movq $-0x1, %r14
testb %al, %al
je 0x2bfd2
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq 0x18(%r15), %rsi
movq %rax, %rdi
callq 0x2f6c6
movq %r14, 0x18(%rbx)
movl 0x28(%r15), %eax
movl %eax, 0x28(%rbx)
decl %eax
cmpl $0x18, %eax
ja 0x2c05b
leaq 0x1b1ad(%rip), %rcx     # 0x47198
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r15), %rax
movq %rax, (%rbx)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rbx)
jmp 0x2c05b
movq (%r15), %rax
movq %rax, (%rbx)
jmp 0x2c05b
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
callq 0x2f6c6
jmp 0x2c058
movl $0x68, %edi
callq 0x42e0
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
callq 0x2f138
jmp 0x2c058
movl $0x18, %edi
callq 0x42e0
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
callq 0x2dff0
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c06c
jmp 0x2c06c
jmp 0x2c06c
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/ParseExpression.cpp
// Function: ParseExpression::ParseExpression(ParseVariable const&)
ParseExpression::ParseExpression(const ParseVariable &variable) {
    const_value = 0;
    ret_type_id = variable.get_type().get_id();
    expr_type = E_VAR;
    child[0] = (size_t)
            new ParseVariable(variable);
    update(*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, 0x18(%rdi)
movq %rsi, %rdi
callq 0x2efec
movq %rax, %rdi
callq 0x2770a
movq %rax, 0x20(%rbx)
movl $0x1, 0x28(%rbx)
movl $0x68, %edi
callq 0x42e0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x2f138
movq %r14, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b7a0
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/ParseExpression.cpp
// Function: ParseExpression::ParseExpression(std::vector<ParseFunction const*, std::allocator<ParseFunction const*>> const&)
ParseExpression::ParseExpression(const DecFuncPtrList &func_list) {
    if (func_list.empty()) {
        string info = "ParseExpression(const vector<const ParseFunction *> &func_list)";
        throw ParseException(EX_INVALID_FUNC_EXPRESSION, info);
    }
    const_value = 0;
    ret_type_id = (func_list[0])->get_ret_type().get_id();
    expr_type = E_FUN;
    child[0] = (size_t) new DecFuncPtrList(func_list);
    update(*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x2c171
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x18(%rdi)
movq (%rax), %rsi
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x2f18e
movq %r15, %rdi
callq 0x2770a
movq %rax, 0x20(%rbx)
leaq -0x50(%rbp), %rdi
callq 0x28344
movl $0x2, 0x28(%rbx)
movl $0x18, %edi
callq 0x42e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2dff0
movq %r15, (%rbx)
movq %rbx, %rdi
callq 0x2b7a0
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1b182(%rip), %rsi     # 0x47302
leaq 0x1b1ba(%rip), %rdx     # 0x47341
leaq -0x50(%rbp), %rdi
callq 0xf65c
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
leaq -0x50(%rbp), %rdx
movq %rax, %rdi
movl $0x15, %esi
callq 0x33d12
leaq 0x2fbbb(%rip), %rsi     # 0x5bd70
leaq -0x1de02(%rip), %rdx    # 0xe3ba
movq %r14, %rdi
callq 0x4540
movq %rax, %rbx
jmp 0x2c1d4
movq %rax, %rbx
movq %r14, %rdi
callq 0x4250
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
jne 0x2c1ea
jmp 0x2c1fd
movq %rax, %rbx
jmp 0x2c1fd
movq %rax, %rbx
movq %r15, %rdi
callq 0x42b0
jmp 0x2c1fd
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x28344
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::~ParseExpression()
ParseExpression::~ParseExpression() {
    if (is_const()) {
        delete (ParseConstant *) const_value;
    }
    switch (expr_type) {
        case E_FUN:
            delete (DecFuncPtrList *) child[0];
            break;
        case E_VAR:
            delete (ParseVariable *) child[0];
            break;
        case E_CONST:
            if (child[0] != const_value) {
                delete (ParseConstant *) child[0];
            }
            break;
        case E_UNDEFINED:
        case E_ADD:
        case E_SUB:
        case E_MUL:
        case E_DIV:
        case E_MOD:
        case E_POW:
        case E_NOT:
        case E_LOGIC_OR:
        case E_LOGIC_AND:
        case E_G:
        case E_GE:
        case E_EQUAL:
        case E_NE:
        case E_L:
        case E_LE:
        case E_ASSIGN:
        case E_GET_ITEM:
        case E_ADR:
        case E_PTR:
        case E_NEG:
        case E_POS:
        case E_BIT_NOT:
            return;

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x2bb90
testb %al, %al
je 0x2c4aa
movq 0x18(%r14), %rbx
testq %rbx, %rbx
je 0x2c4aa
movq %rbx, %rdi
callq 0x2fac8
movq %rbx, %rdi
callq 0x42b0
movl 0x28(%r14), %eax
cmpl $0x1, %eax
je 0x2c4ec
cmpl $0x3, %eax
je 0x2c4d4
cmpl $0x2, %eax
jne 0x2c51a
movq (%r14), %rbx
testq %rbx, %rbx
je 0x2c51a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2c50e
callq 0x42b0
jmp 0x2c50e
movq (%r14), %rbx
testq %rbx, %rbx
je 0x2c51a
cmpq 0x18(%r14), %rbx
je 0x2c51a
movq %rbx, %rdi
callq 0x2fac8
jmp 0x2c50e
movq (%r14), %rbx
testq %rbx, %rbx
je 0x2c51a
movq 0x38(%rbx), %rdi
leaq 0x48(%rbx), %rax
cmpq %rax, %rdi
je 0x2c506
callq 0x42b0
movq %rbx, %rdi
callq 0x28344
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x42b0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0xe590
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::operator=(ParseVariable const&)
ParseExpression &ParseExpression::operator=(const ParseVariable &variable) {
    if (id2expr.empty()) {
        init();
    }
    expr_type = E_VAR;
    child[0] = (size_t)
            new ParseVariable(variable);
    update(*this);
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30e81(%rip), %rax     # 0x5d3c0
cmpq 0x30e82(%rip), %rax     # 0x5d3c8
jne 0x2c54d
callq 0x2c206
movl $0x1, 0x28(%rbx)
movl $0x68, %edi
callq 0x42e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2f138
movq %r15, (%rbx)
movq %rbx, %rdi
callq 0x2b7a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::get_id() const
size_t ParseExpression::get_expr_id(const ParseExpression &expr) {
    if (expr.expr_id) {
        return expr.expr_id;
    }
    update(expr);
    return expr.expr_id;
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x2cfac
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2b7a0
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::get_const() const
const ParseConstant &ParseExpression::get_const() const {
    ((ParseExpression *) this)->calculate_const();
    if (is_const()) {
        return *(ParseConstant *) const_value;
    }
    string info = "ParseExpression::get_const() expr_id=";
    info += to_string(expr_id);
    throw ParseException(EX_EXPRESSION_NOT_CONST, info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x343a4
movq %rbx, %rdi
callq 0x2bb90
testb %al, %al
je 0x2d4b8
movq 0x18(%rbx), %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a0b1(%rip), %rsi     # 0x47578
leaq 0x1a0cf(%rip), %rdx     # 0x4759d
leaq -0x58(%rbp), %rdi
callq 0xf65c
movq 0x10(%rbx), %rsi
leaq -0x38(%rbp), %rdi
callq 0xe329
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x4110
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d507
callq 0x42b0
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
leaq -0x58(%rbp), %rdx
movq %rax, %rdi
movl $0xb, %esi
callq 0x33d12
leaq 0x2e844(%rip), %rsi     # 0x5bd70
leaq -0x1f179(%rip), %rdx    # 0xe3ba
movq %r14, %rdi
callq 0x4540
jmp 0x2d561
movq %rax, %rbx
movq %r14, %rdi
callq 0x4250
jmp 0x2d564
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d564
callq 0x42b0
jmp 0x2d564
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2d572
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::get_variable() const
const ParseVariable &ParseExpression::get_variable() const {
    if (is_variable()) {
        return *(ParseVariable *) child[0];
    }
    string info = "ParseExpression::get_variable() expr_id=";
    info += to_string(expr_id);
    throw ParseException(EX_EXPRESSION_NOT_VARIABLE, info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $0x1, 0x28(%rdi)
jne 0x2d59e
movq (%rbx), %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x19ff1(%rip), %rsi     # 0x4759e
leaq 0x1a012(%rip), %rdx     # 0x475c6
leaq -0x58(%rbp), %rdi
callq 0xf65c
movq 0x10(%rbx), %rsi
leaq -0x38(%rbp), %rdi
callq 0xe329
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x4110
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d5ed
callq 0x42b0
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
leaq -0x58(%rbp), %rdx
movq %rax, %rdi
movl $0xc, %esi
callq 0x33d12
leaq 0x2e75e(%rip), %rsi     # 0x5bd70
leaq -0x1f25f(%rip), %rdx    # 0xe3ba
movq %r14, %rdi
callq 0x4540
jmp 0x2d647
movq %rax, %rbx
movq %r14, %rdi
callq 0x4250
jmp 0x2d64a
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d64a
callq 0x42b0
jmp 0x2d64a
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2d658
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::get_functions() const
const DecFuncPtrList &ParseExpression::get_functions() const {
    if (is_function()) {
        return *(DecFuncPtrList *) child[0];
    }
    string info = "ParseExpression::get_functions() expr_id=";
    info += to_string(expr_id);
    throw ParseException(EX_EXPRESSION_NOT_FUNCTION, info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $0x2, 0x28(%rdi)
jne 0x2d692
movq (%rbx), %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x19f26(%rip), %rsi     # 0x475c7
leaq 0x19f48(%rip), %rdx     # 0x475f0
leaq -0x58(%rbp), %rdi
callq 0xf65c
movq 0x10(%rbx), %rsi
leaq -0x38(%rbp), %rdi
callq 0xe329
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x4110
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d6e1
callq 0x42b0
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
leaq -0x58(%rbp), %rdx
movq %rax, %rdi
movl $0xd, %esi
callq 0x33d12
leaq 0x2e66a(%rip), %rsi     # 0x5bd70
leaq -0x1f353(%rip), %rdx    # 0xe3ba
movq %r14, %rdi
callq 0x4540
jmp 0x2d73b
movq %rax, %rbx
movq %r14, %rdi
callq 0x4250
jmp 0x2d73e
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d73e
callq 0x42b0
jmp 0x2d73e
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2d74c
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseVariable::operator<(ParseVariable const&) const
bool ParseVariable::operator<(const ParseVariable &other) const {
    if (type < other.type) {
        return true;
    } else if (other.type < type) {
        return false;
    }
    if (scope_id < other.scope_id) {
        return true;
    } else if (other.scope_id < scope_id) {
        return false;
    }
    if (address < other.address) {
        return true;
    } else if (other.address < address) {
        return false;
    }
    if (symbol.length() < other.symbol.length()) {
        return true;
    } else if (other.symbol.length() < symbol.length()) {
        return false;
    }
    for (size_t i = 0; i < symbol.length(); ++i) {
        if (symbol[i] < other.symbol[i]) {
            return true;
        } else if (other.symbol[i] < symbol[i]) {
            return false;
        }
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x289bc
movb $0x1, %bl
testb %al, %al
jne 0x2f07d
movq %r14, %rdi
movq %r15, %rsi
callq 0x289bc
testb %al, %al
je 0x2f070
xorl %ebx, %ebx
jmp 0x2f07d
movq 0x60(%r15), %rax
movq 0x60(%r14), %rcx
cmpq %rcx, %rax
jae 0x2f08d
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
ja 0x2f06c
movq 0x58(%r15), %rax
movq 0x58(%r14), %rcx
cmpq %rcx, %rax
jb 0x2f07d
ja 0x2f06c
movq 0x40(%r15), %rcx
movq 0x40(%r14), %rax
cmpq %rax, %rcx
jb 0x2f07d
ja 0x2f06c
testq %rcx, %rcx
setne %bl
je 0x2f0ee
movq 0x38(%r15), %rdx
movq 0x38(%r14), %rsi
movb (%rdx), %r8b
movb (%rsi), %r9b
movb $0x1, %al
cmpb %r9b, %r8b
jl 0x2f0ee
movl $0x1, %edi
cmpb %r8b, %r9b
jl 0x2f0f2
cmpq %rcx, %rdi
setb %bl
je 0x2f0ee
movb (%rdx,%rdi), %r8b
movb (%rsi,%rdi), %r9b
incq %rdi
cmpb %r9b, %r8b
jge 0x2f0cf
jmp 0x2f0ee
andb %al, %bl
jmp 0x2f07d
xorl %eax, %eax
jmp 0x2f0ee
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseVariable::operator=(ParseVariable const&)
ParseVariable &ParseVariable::operator=(const ParseVariable &other) {
    type = other.type;
    address = other.address;
    symbol = other.symbol;
    scope_id = other.scope_id;
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x28300
movq 0x58(%rbx), %rax
movq %rax, 0x58(%r14)
leaq 0x38(%rbx), %rsi
leaq 0x38(%r14), %rdi
callq 0x41b0
movq 0x60(%rbx), %rax
movq %rax, 0x60(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::assign(ParseConstant&, ParseConstant const&)
void ParseConstant::assign(ParseConstant &constant, const ParseConstant &from_constant) {
    constant.type = from_constant.type;
    switch (constant.type) {
        case C_STRING:
            constant.value = (size_t) new string(*(string *) from_constant.value);
            break;
        case C_SIGNED:
            constant.value = (size_t) new long long(*(long long *) from_constant.value);
            break;
        case C_UNSIGNED:
            constant.value = (size_t) new unsigned long long(*(unsigned long long *) from_constant.value);
            break;
        case C_FLOAT:
            constant.value = (size_t) new long double(*(long double *) from_constant.value);
            break;
        case C_BOOL:
            constant.value = (size_t) new bool(*(bool *) from_constant.value);
            break;
        case C_UNDEFINED:
            constant.value = 0;
            break;
    }
}

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x2fa01
leaq 0x17d5e(%rip), %rcx     # 0x4770c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
fildll -0x10(%rbp)
jmp 0x2fa0f
movq 0x8(%rdi), %rax
fldt (%rax)
jmp 0x2fa0f
movq 0x8(%rdi), %rax
movsbl (%rax), %eax
movw %ax, -0x2(%rbp)
filds -0x2(%rbp)
jmp 0x2fa0f
movq 0x8(%rdi), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
xorl %ecx, %ecx
testq %rax, %rax
sets %cl
fildll -0x18(%rbp)
leaq 0x17dd4(%rip), %rax     # 0x477d0
fadds (%rax,%rcx,4)
jmp 0x2fa0f
leaq 0x1848e(%rip), %rdi     # 0x47e96
callq 0x4480
fldz
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fa57
leaq 0x17cf6(%rip), %rcx     # 0x4771c
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 0x18475(%rip), %rdi     # 0x47ed7
callq 0x4480
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2faa1
leaq 0x18496(%rip), %rdi     # 0x47f17
callq 0x4480
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x16898(%rip), %rdx     # 0x4632c
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xf65c
jmp 0x2fabe
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 0xf5c2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq