LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x196d3
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %r14, %rsi
callq 0x1b56e
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movl $0x100, %esi            # imm = 0x100
xorl %ecx, %ecx
callq 0x1b5aa
leaq -0x30(%rbp), %rdi
callq 0x11064
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x18f0c
movq %rax, %rdi
movq %r14, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1b56e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x11064
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::collect_parameters_list() const
void ParseNode::collect_parameters_list() const {
    auto &the_map = tree.node_param_list;
    // 结果
    vector<ParseVariable> res;
    switch (type) {
        case N_PARAM_LIST: {
            // 允许此操作的节点
            // 收集所有对应子节点类型的信息
            for (const auto &each : tree.node_children[node_id]) {
                const ParseNode &node = tree.nodes[each];
                if (node.type == N_PARAM_DECLARATION) {
                    res.emplace_back(node.get_variable());
                }
            }
            break;
        }
        default: {
            // 不允许此操作的节点
            string info = "ParseNode::collect_parameters_list(): node_type=";
            info += get_node_type_name(type);
            info += " node_id=" + to_string(node_id);
            throw ParseException(EX_NODE_NOT_ALLOW_OP, info);
        }
    }
    // 这里强制转换成非常量指针来改变keys表示该节点拥有这个键值
    ((ParseNode *) this)->keys |= K_PARAM_LIST;
    the_map[node_id] = res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %r14
andq $0x0, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
cmpl $0x8, 0x18(%rdi)
jne 0x19e2b
movq 0x60(%r14), %rax
imulq $0x18, (%rbx), %rcx
addq $0x498, %r14            # imm = 0x498
movq (%rax,%rcx), %r12
movq 0x8(%rax,%rcx), %r13
leaq -0x40(%rbp), %r15
cmpq %r13, %r12
je 0x19df8
movq 0x10(%rbx), %rcx
movq (%r12), %rax
movq (%rcx), %rdi
shlq $0x5, %rax
cmpl $0x9, 0x18(%rdi,%rax)
jne 0x19df2
addq %rax, %rdi
callq 0x18e96
movq %r15, %rdi
movq %rax, %rsi
callq 0x1df02
addq $0x8, %r12
jmp 0x19dc4
orb $0x10, 0xa(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1df3e
leaq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x1df90
leaq -0x40(%rbp), %rdi
callq 0xcb78
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20e0d(%rip), %rsi     # 0x3ac3f
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x4130
movl 0x18(%rbx), %esi
leaq -0x60(%rbp), %r14
movq %r14, %rdi
callq 0x17f38
leaq -0x80(%rbp), %rdi
movq %r14, %rsi
callq 0x4580
leaq -0x60(%rbp), %rdi
callq 0x4598
movq (%rbx), %rsi
leaq -0xa0(%rbp), %rdi
callq 0xc865
leaq 0x20877(%rip), %rsi     # 0x3a6f0
leaq -0x60(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
callq 0xc837
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4580
leaq -0x60(%rbp), %rdi
callq 0x4598
leaq -0xa0(%rbp), %rdi
callq 0x4598
pushq $0x28
popq %rdi
callq 0x4180
movq %rax, %r14
pushq $0x4
popq %rsi
leaq -0x80(%rbp), %rdx
movq %rax, %rdi
callq 0x2b53c
leaq 0x38ea4(%rip), %rsi     # 0x52d70
leaq -0xd62b(%rip), %rdx     # 0xc8a8
movq %r14, %rdi
callq 0x44e0
jmp 0x19f04
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x19f15
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x4598
jmp 0x19efb
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
jmp 0x19f10
movq %rax, %rbx
jmp 0x19f15
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x4598
leaq -0x80(%rbp), %rdi
callq 0x4598
jmp 0x19f27
jmp 0x19f24
jmp 0x19f24
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xcb78
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21132
movq %r15, %rdi
callq 0x1139a
movq %r15, %rdi
callq 0x4270
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x2115b
pushq $0x30
popq %rdi
callq 0x42a0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x22ca2
jmp 0x2115e
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 0x4270
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x2152e
movq %rdx, %r15
cmpq $0x0, 0x28(%r14)
je 0x21563
movq %rbx, %rdi
movq %r14, %rsi
callq 0x210f4
orq $-0x1, 0x18(%rbx)
addq %r15, 0x28(%rbx)
jmp 0x21591
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x215a0
movq (%r15), %rsi
leaq 0x1992a(%rip), %rdi     # 0x3ae71
xorl %eax, %eax
callq 0x4060
movq %r15, %rdi
callq 0x4598
movq %rbx, %rdi
movq %r14, %rsi
callq 0x210f4
jmp 0x21591
movq %r14, %rdi
callq 0x21942
andl $0x0, (%rbx)
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
andl $0x0, 0x4(%rbx)
movq $0x8, 0x20(%rbx)
movq %r15, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
orq $-0x1, 0x18(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3296f(%rip), %rax     # 0x542c8
cmpq 0x32970(%rip), %rax     # 0x542d0
jne 0x21967
callq 0x21e7c
movq 0x18(%rbx), %rax
cmpq $-0x1, %rax
jne 0x21a06
leaq 0x3291c(%rip), %rdi     # 0x54298
movq %rbx, %rsi
callq 0x23be4
leaq 0x32915(%rip), %rcx     # 0x542a0
cmpq %rcx, %rax
je 0x2199a
movq 0x58(%rax), %rax
movq %rax, 0x18(%rbx)
jmp 0x21a06
leaq 0x32927(%rip), %r14     # 0x542c8
movq 0x32928(%rip), %rax     # 0x542d0
subq 0x32919(%rip), %rax     # 0x542c8
pushq $0x38
popq %rcx
cqto
idivq %rcx
movq %rax, %r15
movq %rax, 0x18(%rbx)
leaq 0x328d3(%rip), %rdi     # 0x54298
movq %rbx, %rsi
callq 0x22a46
movq %r15, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22ab0
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x215a0
leaq 0x328ef(%rip), %rdi     # 0x542e0
movq %r14, %rsi
callq 0x12f32
leaq -0x38(%rbp), %rdi
callq 0x4598
movq 0x18(%rbx), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x32892(%rip), %rcx     # 0x542c8
movq 0x32893(%rip), %rax     # 0x542d0
cmpq %rax, %rcx
jne 0x21a55
callq 0x21e7c
movq 0x32882(%rip), %rax     # 0x542d0
movq 0x32873(%rip), %rcx     # 0x542c8
subq %rcx, %rax
pushq $0x38
popq %rsi
cqto
idivq %rsi
cmpq %rbx, %rax
jbe 0x21a6e
imulq $0x38, %rbx, %rax
addq %rax, %rcx
jmp 0x21a86
leaq 0x19462(%rip), %rdi     # 0x3aed7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4060
movq 0x32842(%rip), %rcx     # 0x542c8
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::get_base_type_name[abi:cxx11](BaseType, int)
string ParseType::get_base_type_name(BaseType base_type, int specifier) {
    string res;
    if (specifier & S_UNSIGNED) {
        res += "unsigned ";
    }
    if (specifier & S_LONG) {
        res += "long ";
    }
    switch (base_type) {
        case T_UNKNOWN:
            return "unknown";
        case T_SHORT:
            return res + "short";
        case T_INT:
            return res + "int";
        case T_LONG:
            return res + "long";
        case T_FLOAT:
            return res + "float";
        case T_DOUBLE:
            return res + "double";
        case T_BOOL:
            return "bool";
        case T_CHAR:
            return "char";
        case T_ENUM:
            return "enum";
        case T_VOID:
            return "void";
    }
    return "unknown";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %r15d
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movl %esi, %r14d
movq %rdi, %rbx
movb $0x0, (%rax)
testb $0x1, %r15b
je 0x21acc
leaq 0x19382(%rip), %rsi     # 0x3ae45
leaq -0x40(%rbp), %rdi
callq 0x4540
testb $0x2, %r15b
je 0x21ae2
leaq 0x19376(%rip), %rsi     # 0x3ae4f
leaq -0x40(%rbp), %rdi
callq 0x4540
cmpl $0x9, %r14d
ja 0x21ba1
movl %r14d, %eax
leaq 0x192e6(%rip), %rcx     # 0x3addc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x18b0d(%rip), %rsi     # 0x3a613
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
callq 0x4130
jmp 0x21b8a
leaq 0x19ccc(%rip), %rdx     # 0x3b7e7
jmp 0x21b7e
leaq 0x19348(%rip), %rsi     # 0x3ae6c
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
callq 0x4130
jmp 0x21b8a
leaq 0x1932e(%rip), %rsi     # 0x3ae67
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
callq 0x4130
jmp 0x21b8a
leaq 0x19307(%rip), %rdx     # 0x3ae55
jmp 0x21b7e
leaq 0x19309(%rip), %rdx     # 0x3ae60
jmp 0x21b7e
leaq 0x19cb0(%rip), %rsi     # 0x3b810
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
callq 0x4130
jmp 0x21b8a
leaq 0x192e6(%rip), %rdx     # 0x3ae5b
jmp 0x21b7e
leaq 0x19c86(%rip), %rdx     # 0x3b804
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0xca9e
leaq -0x40(%rbp), %rdi
callq 0x4598
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18a6b(%rip), %rsi     # 0x3a613
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
callq 0x4130
jmp 0x21b8a
leaq 0x18e82(%rip), %rsi     # 0x3aa3f
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
callq 0x4130
jmp 0x21b8a
jmp 0x21bd7
jmp 0x21bd7
jmp 0x21bd7
jmp 0x21bd7
jmp 0x21bd7
jmp 0x21bd7
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x28(%rdi)
orq $-0x1, 0x18(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
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)
orq $-0x1, 0x18(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2246f
movq %rsi, %r14
movq %rdx, %rsi
callq 0x17536
movq 0x10(%r14), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x2246f
imulq $0x38, 0x40(%rax), %rsi
addq 0x31e63(%rip), %rsi     # 0x542c8
movq %rbx, %rdi
callq 0x210f4
jmp 0x22486
andl $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x28(%rbx)
orq $-0x1, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpl $0x0, (%rdi)
je 0x2249f
movq 0x8(%rdi), %rbx
jmp 0x224b7
callq 0x212de
leaq 0x18a95(%rip), %rdi     # 0x3af40
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x4060
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x22926
cmpq %rbx, %r14
setae %al
jmp 0x2294e
movq %r14, %rdi
callq 0x21a26
movq %rax, %r15
movq %rbx, %rdi
callq 0x21a26
movl (%r15), %ecx
testl %ecx, %ecx
je 0x2291e
cmpl (%rax), %ecx
jne 0x2291e
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_O2/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 0x2fc61(%rip), %rax     # 0x54390
cmpq 0x2fc62(%rip), %rax     # 0x54398
jne 0x2473d
callq 0x24f68
leaq 0x2fc1c(%rip), %rdi     # 0x54360
movq %rbx, %rsi
callq 0x2706a
leaq 0x2fc15(%rip), %rcx     # 0x54368
cmpq %rcx, %rax
je 0x24762
movq 0x50(%rax), %rax
movq %rax, 0x10(%rbx)
jmp 0x247da
leaq 0x2fc27(%rip), %r14     # 0x54390
movq 0x2fc28(%rip), %rax     # 0x54398
subq 0x2fc19(%rip), %rax     # 0x54390
pushq $0x30
popq %r12
cqto
idivq %r12
movq %rax, %r15
leaq 0x2fbd6(%rip), %rdi     # 0x54360
movq %rbx, %rsi
callq 0x267c4
movq %r15, (%rax)
movq 0x2fbfc(%rip), %rax     # 0x54398
subq 0x2fbed(%rip), %rax     # 0x54390
cqto
idivq %r12
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2682e
leaq -0x24(%rbp), %rsi
andl $0x0, (%rsi)
leaq 0x2fbe3(%rip), %rdi     # 0x543a8
callq 0x26732
movq 0x2fbc7(%rip), %rdi     # 0x54398
addq $-0x30, %rdi
callq 0x52c4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2fb98(%rip), %rcx     # 0x54390
movq 0x2fb99(%rip), %rax     # 0x54398
cmpq %rax, %rcx
jne 0x24817
callq 0x24f68
movq 0x2fb88(%rip), %rax     # 0x54398
movq 0x2fb79(%rip), %rcx     # 0x54390
subq %rcx, %rax
pushq $0x30
popq %rsi
cqto
idivq %rsi
cmpq %rbx, %rax
jbe 0x24830
imulq $0x30, %rbx, %rax
addq %rax, %rcx
jmp 0x24848
leaq 0x16aa3(%rip), %rdi     # 0x3b2da
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4060
movq 0x2fb48(%rip), %rcx     # 0x54390
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::get_expr_type_name[abi:cxx11](ExpressionType)
string ParseExpression::get_expr_type_name(ExpressionType type) {
    switch (type) {
        case E_UNDEFINED:
            break;
        case E_POS:
        case E_ADD:
            return "+";
        case E_NEG:
        case E_SUB:
            return "-";
        case E_MUL:
            return "*";
        case E_DIV:
            return "/";
        case E_POW:
            return "^";
        case E_LOGIC_OR:
            return "||";
        case E_LOGIC_AND:
            return "&&";
        case E_G:
            return ">";
        case E_GE:
            return ">=";
        case E_EQUAL:
            return "==";
        case E_NE:
            return "!=";
        case E_L:
            return "<";
        case E_LE:
            return "<=";
        case E_VAR:
            return "variable";
        case E_CONST:
            return "const";
        case E_MOD:
            return "%";
        case E_ASSIGN:
            return "=";
        case E_GET_ITEM:
            return "[]";
        case E_NOT:
            return "!";
        case E_ADR:
            return "&";
        case E_PTR:
            return "*";
        case E_BIT_NOT:
            return "~";
        case E_FUN:
            return "function";
    }
    return "undefined";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl %esi
cmpl $0x18, %esi
ja 0x24954
leaq 0x167fb(%rip), %rax     # 0x3b068
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x1462c(%rip), %rsi     # 0x38ea9
jmp 0x2495b
leaq 0x15aba(%rip), %rsi     # 0x3a343
jmp 0x2495b
leaq 0x16973(%rip), %rsi     # 0x3b208
jmp 0x2495b
leaq 0x15abe(%rip), %rsi     # 0x3a35f
jmp 0x2495b
leaq 0x15ab0(%rip), %rsi     # 0x3a35d
jmp 0x2495b
leaq 0x15a8e(%rip), %rsi     # 0x3a347
jmp 0x2495b
leaq 0x13ed6(%rip), %rsi     # 0x3879b
jmp 0x2495b
leaq 0x13e5a(%rip), %rsi     # 0x3872b
jmp 0x2495b
leaq 0x169b1(%rip), %rsi     # 0x3b28e
jmp 0x2495b
leaq 0x13b2a(%rip), %rsi     # 0x38410
jmp 0x2495b
leaq 0x15a6d(%rip), %rsi     # 0x3a35c
jmp 0x2495b
leaq 0x13cab(%rip), %rsi     # 0x385a3
jmp 0x2495b
leaq 0x16004(%rip), %rsi     # 0x3a905
jmp 0x2495b
leaq 0x135d9(%rip), %rsi     # 0x37ee3
jmp 0x2495b
leaq 0x1373b(%rip), %rsi     # 0x3804e
jmp 0x2495b
leaq 0x13736(%rip), %rsi     # 0x38052
jmp 0x2495b
leaq 0x15a3d(%rip), %rsi     # 0x3a362
jmp 0x2495b
leaq 0x1366e(%rip), %rsi     # 0x37f9c
jmp 0x2495b
leaq 0x15a0e(%rip), %rsi     # 0x3a345
jmp 0x2495b
leaq 0x13700(%rip), %rsi     # 0x38040
jmp 0x2495b
leaq 0x13701(%rip), %rsi     # 0x3804a
jmp 0x2495b
leaq 0x136f1(%rip), %rsi     # 0x38043
jmp 0x2495b
leaq 0x16935(%rip), %rsi     # 0x3b290
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x4130
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x249af
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq $-0x1, %rax
je 0x249a7
testq %rax, %rax
jne 0x2499e
movq %rbx, %rdi
callq 0x2b9ac
movq 0x18(%rbx), %rax
cmpq $-0x1, %rax
setne %al
jmp 0x249a9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
orq $-0x1, 0x20(%rdi)
andl $0x0, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
pushq $0x10
popq %rdi
callq 0x42a0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2796e
movq %r15, (%rbx)
movq %r15, 0x18(%rbx)
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x21302
movq %r15, %rdi
callq 0x212de
movq %rax, 0x20(%rbx)
leaq -0x50(%rbp), %rdi
callq 0x21c36
movq %rbx, %rdi
callq 0x24716
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x21c36
jmp 0x24cf9
movq %rax, %rbx
movq %r15, %rdi
callq 0x4270
movq %rbx, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/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 0x24972
testb %al, %al
je 0x24d51
pushq $0x10
popq %rdi
callq 0x42a0
movq %rax, %r14
movq 0x18(%r15), %rsi
movq %rax, %rdi
callq 0x2796e
jmp 0x24d55
pushq $-0x1
popq %r14
movq %r14, 0x18(%rbx)
movl 0x28(%r15), %eax
movl %eax, 0x28(%rbx)
decl %eax
cmpl $0x18, %eax
ja 0x24dd8
leaq 0x163c2(%rip), %rcx     # 0x3b130
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 0x24dd8
movq (%r15), %rax
movq %rax, (%rbx)
jmp 0x24dd8
pushq $0x10
popq %rdi
callq 0x42a0
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
callq 0x2796e
jmp 0x24dd5
pushq $0x68
popq %rdi
callq 0x42a0
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
callq 0x2761e
jmp 0x24dd5
pushq $0x18
popq %rdi
callq 0x42a0
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
callq 0x2669e
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x24de9
jmp 0x24de9
jmp 0x24de9
movq %rax, %rbx
movq %r14, %rdi
callq 0x4270
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x18(%rdi)
movq %rsi, %rdi
callq 0x274f6
movq %rax, %rdi
callq 0x212de
movq %rax, 0x20(%rbx)
movl $0x1, 0x28(%rbx)
pushq $0x68
popq %rdi
callq 0x42a0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x2761e
movq %r14, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x24716
movq %rax, %rbx
movq %r14, %rdi
callq 0x4270
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x24ee2
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x18(%rdi)
movq (%rax), %rsi
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x27666
movq %r15, %rdi
callq 0x212de
movq %rax, 0x20(%rbx)
leaq -0x58(%rbp), %rdi
callq 0x21c36
movl $0x2, 0x28(%rbx)
pushq $0x18
popq %rdi
callq 0x42a0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2669e
movq %r15, (%rbx)
movq %rbx, %rdi
callq 0x24716
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x163b1(%rip), %rsi     # 0x3b29a
leaq -0x58(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x4130
pushq $0x28
popq %rdi
callq 0x4180
movq %rax, %r14
pushq $0x15
popq %rsi
leaq -0x58(%rbp), %rdx
movq %rax, %rdi
callq 0x2b53c
leaq 0x2de59(%rip), %rsi     # 0x52d70
leaq -0x18676(%rip), %rdx    # 0xc8a8
movq %r14, %rdi
callq 0x44e0
movq %rax, %rbx
jmp 0x24f36
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
leaq -0x58(%rbp), %rdi
callq 0x4598
jmp 0x24f5f
movq %rax, %rbx
jmp 0x24f5f
movq %rax, %rbx
movq %r15, %rdi
callq 0x4270
jmp 0x24f5f
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x21c36
movq %rbx, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x24972
testb %al, %al
je 0x2517c
movq 0x18(%r14), %rbx
testq %rbx, %rbx
je 0x25174
movq %rbx, %rdi
callq 0x27d24
movq %rbx, %rdi
callq 0x4270
movl 0x28(%r14), %eax
cmpl $0x1, %eax
je 0x251af
cmpl $0x3, %eax
je 0x251a1
cmpl $0x2, %eax
jne 0x251aa
movq (%r14), %rbx
testq %rbx, %rbx
je 0x251ce
movq %rbx, %rdi
callq 0xdab0
jmp 0x251ce
movq (%r14), %rbx
cmpq 0x18(%r14), %rbx
jne 0x251c1
popq %rbx
popq %r14
popq %rbp
retq
movq (%r14), %rbx
testq %rbx, %rbx
je 0x251ce
movq %rbx, %rdi
callq 0xca7e
jmp 0x251ce
testq %rbx, %rbx
je 0x251ce
movq %rbx, %rdi
callq 0x27d24
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4270
movq %rax, %rdi
callq 0xca0b
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2f197(%rip), %rax     # 0x54390
cmpq 0x2f198(%rip), %rax     # 0x54398
jne 0x25207
callq 0x24f68
movl $0x1, 0x28(%rbx)
pushq $0x68
popq %rdi
callq 0x42a0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2761e
movq %r15, (%rbx)
movq %rbx, %rdi
callq 0x24716
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x4270
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::get_logic_expression(ExpressionType, ParseExpression const&, ParseExpression const&)
const ParseExpression &
ParseExpression::get_logic_expression(ExpressionType type,
                                      const ParseExpression &expr1, const ParseExpression &expr2) {
    switch (type) {
        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:
            return generate_expression(type, expr1, expr2);
        default:
            break;
    }
    // 错误调用
    string info = "ParseExpression::get_logic_expression(ExpressionType type,"
                  "const ParseExpression &expr1, const ParseExpression &expr2)";
    info += " expr1=" + to_string(expr1.get_id());
    info += " expr2=" + to_string(expr2.get_id());
    throw ParseException(EX_EXPRESSION_CAN_NOT_GENERATE, info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leal -0x11(%rdi), %eax
cmpl $0x7, %eax
ja 0x25916
movq %r14, %rsi
movq %rbx, %rdx
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2527e
leaq 0x15a1a(%rip), %rsi     # 0x3b337
leaq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x4130
movq %r14, %rdi
callq 0x25a38
leaq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xc865
leaq 0x12424(%rip), %rsi     # 0x37d69
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0xc837
leaq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4580
leaq -0x30(%rbp), %rdi
callq 0x4598
leaq -0x50(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x25a38
leaq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xc865
leaq 0x123e5(%rip), %rsi     # 0x37d71
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0xc837
leaq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4580
leaq -0x30(%rbp), %rdi
callq 0x4598
leaq -0x50(%rbp), %rdi
callq 0x4598
pushq $0x28
popq %rdi
callq 0x4180
movq %rax, %r14
pushq $0x10
popq %rsi
leaq -0x70(%rbp), %rdx
movq %rax, %rdi
callq 0x2b53c
leaq 0x2d397(%rip), %rsi     # 0x52d70
leaq -0x19138(%rip), %rdx    # 0xc8a8
movq %r14, %rdi
callq 0x44e0
jmp 0x25a19
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x25a1c
jmp 0x259fd
jmp 0x25a0b
jmp 0x25a19
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4598
jmp 0x25a0e
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4598
jmp 0x25a1c
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x2b9ac
movq %rbx, %rdi
callq 0x24972
testb %al, %al
je 0x25dd6
movq 0x18(%rbx), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x15733(%rip), %rsi     # 0x3b510
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x4130
movq 0x10(%rbx), %rsi
leaq -0x30(%rbp), %rdi
callq 0xc865
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4580
leaq -0x30(%rbp), %rdi
callq 0x4598
pushq $0x28
popq %rdi
callq 0x4180
movq %rax, %r14
pushq $0xb
popq %rsi
leaq -0x50(%rbp), %rdx
movq %rax, %rdi
callq 0x2b53c
leaq 0x2cf42(%rip), %rsi     # 0x52d70
leaq -0x1958d(%rip), %rdx    # 0xc8a8
movq %r14, %rdi
callq 0x44e0
jmp 0x25e5a
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x25e5d
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4598
jmp 0x25e5d
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpl $0x1, 0x28(%rdi)
jne 0x25e8e
movq (%rbx), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x156a1(%rip), %rsi     # 0x3b536
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x4130
movq 0x10(%rbx), %rsi
leaq -0x30(%rbp), %rdi
callq 0xc865
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4580
leaq -0x30(%rbp), %rdi
callq 0x4598
pushq $0x28
popq %rdi
callq 0x4180
movq %rax, %r14
pushq $0xc
popq %rsi
leaq -0x50(%rbp), %rdx
movq %rax, %rdi
callq 0x2b53c
leaq 0x2ce8a(%rip), %rsi     # 0x52d70
leaq -0x19645(%rip), %rdx    # 0xc8a8
movq %r14, %rdi
callq 0x44e0
jmp 0x25f12
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x25f15
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4598
jmp 0x25f15
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpl $0x2, 0x28(%rdi)
jne 0x25f54
movq (%rbx), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x15604(%rip), %rsi     # 0x3b55f
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x4130
movq 0x10(%rbx), %rsi
leaq -0x30(%rbp), %rdi
callq 0xc865
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4580
leaq -0x30(%rbp), %rdi
callq 0x4598
pushq $0x28
popq %rdi
callq 0x4180
movq %rax, %r14
pushq $0xd
popq %rsi
leaq -0x50(%rbp), %rdx
movq %rax, %rdi
callq 0x2b53c
leaq 0x2cdc4(%rip), %rsi     # 0x52d70
leaq -0x1970b(%rip), %rdx    # 0xc8a8
movq %r14, %rdi
callq 0x44e0
jmp 0x25fd8
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x25fdb
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4598
jmp 0x25fdb
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::get_item(ParseExpression const&) const
const ParseExpression &ParseExpression::get_item(const ParseExpression &expr) const {
    const ParseType &this_type = get_ret_type();
    ParseExpression res;
    if (!this_type.get_array_size() && !this_type.get_ptr_lv()) {
        string info = "ParseExpression::get_item(const ParseExpression &expr)";
        info += " this_expr=" + to_string(get_id());
        info += " expr=" + to_string(get_id());
        throw ParseException(EX_NOT_AN_ARRAY_TYPE, info);
    }
    res.expr_type = E_GET_ITEM;
    res.ret_type_id = this_type.get_lower_type().get_id();
    res.child[0] = get_id();
    res.child[1] = expr.get_id();
    update(res);
    return get_expression(res.get_id());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x249b0
orq $-0x1, -0x70(%rbp)
andl $0x0, -0x68(%rbp)
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0x80(%rbp)
movq %rax, %rdi
callq 0x21bf6
testq %rax, %rax
jne 0x26485
movq %r15, %rdi
callq 0x2295a
testq %rax, %rax
je 0x26512
movl $0x4, -0x68(%rbp)
leaq -0xc8(%rbp), %rdi
movq %r15, %rsi
callq 0x22964
leaq -0xc8(%rbp), %rdi
callq 0x212de
movq %rax, -0x70(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x21c36
movq %rbx, %rdi
callq 0x25a38
movq %rax, -0x90(%rbp)
movq %r14, %rdi
callq 0x25a38
leaq -0x90(%rbp), %rdi
movq %rax, 0x8(%rdi)
callq 0x24716
leaq -0x90(%rbp), %rdi
callq 0x25a38
movq %rax, %rdi
callq 0x247e8
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x25150
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1510d(%rip), %rsi     # 0x3b626
leaq -0xc8(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x4130
movq %rbx, %rdi
callq 0x25a38
leaq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xc865
leaq 0x15119(%rip), %rsi     # 0x3b65d
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0xc837
leaq -0xc8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4580
leaq -0x38(%rbp), %rdi
callq 0x4598
leaq -0x58(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x25a38
leaq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xc865
leaq 0x14eef(%rip), %rsi     # 0x3b47d
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0xc837
leaq -0xc8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4580
leaq -0x38(%rbp), %rdi
callq 0x4598
leaq -0x58(%rbp), %rdi
callq 0x4598
pushq $0x28
popq %rdi
callq 0x4180
movq %rax, %r14
pushq $0x12
popq %rsi
leaq -0xc8(%rbp), %rdx
movq %rax, %rdi
callq 0x2b53c
leaq 0x2c78f(%rip), %rsi     # 0x52d70
leaq -0x19d40(%rip), %rdx    # 0xc8a8
movq %r14, %rdi
callq 0x44e0
jmp 0x26621
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x26624
jmp 0x26605
jmp 0x26613
jmp 0x26621
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4598
jmp 0x26616
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4598
jmp 0x26624
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x4598
jmp 0x2664a
jmp 0x26647
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x21c36
jmp 0x2664a
jmp 0x26647
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x25150
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseVariable::get_info[abi:cxx11]() const
string ParseVariable::get_info() const {
    string res = "ParseVariable { type:" + type.get_info();
    res += ", symbol:" + symbol;
    res += ", address:" + to_string(address);
    res += ", scope_id:" + to_string(scope_id);
    res += "}";
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x215a0
leaq 0x1439e(%rip), %rsi     # 0x3b770
movq %rbx, %rdi
movq %r15, %rdx
callq 0xc837
leaq -0x38(%rbp), %rdi
callq 0x4598
leaq 0x38(%r14), %rdx
leaq 0x14395(%rip), %rsi     # 0x3b786
leaq -0x38(%rbp), %rdi
callq 0xcad6
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x4580
leaq -0x38(%rbp), %rdi
callq 0x4598
movq 0x58(%r14), %rsi
leaq -0x58(%rbp), %rdi
callq 0xc865
leaq 0x1439f(%rip), %rsi     # 0x3b7c2
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0xc837
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x4580
leaq -0x38(%rbp), %rdi
callq 0x4598
leaq -0x58(%rbp), %rdi
callq 0x4598
movq 0x60(%r14), %rsi
leaq -0x58(%rbp), %rdi
callq 0xc865
leaq 0x1432e(%rip), %rsi     # 0x3b790
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0xc837
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x4580
leaq -0x38(%rbp), %rdi
callq 0x4598
leaq -0x58(%rbp), %rdi
callq 0x4598
leaq 0x13d84(%rip), %rsi     # 0x3b218
movq %rbx, %rdi
callq 0x4540
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x274d9
jmp 0x274b2
jmp 0x274c0
jmp 0x274d9
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x4598
jmp 0x274c3
movq %rax, %r14
leaq -0x58(%rbp), %rdi
jmp 0x274d2
jmp 0x274d9
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x4598
jmp 0x274dc
movq %rax, %r14
movq %rbx, %rdi
callq 0x4598
movq %r14, %rdi
callq 0x4500
movq %rax, %r14
leaq -0x38(%rbp), %rdi
jmp 0x274df
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2214a
movb $0x1, %bl
testb %al, %al
jne 0x27575
movq %r14, %rdi
movq %r15, %rsi
callq 0x2214a
testb %al, %al
je 0x27568
xorl %ebx, %ebx
jmp 0x27575
movq 0x60(%r15), %rax
movq 0x60(%r14), %rcx
cmpq %rcx, %rax
jae 0x27582
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
ja 0x27564
movq 0x58(%r15), %rax
movq 0x58(%r14), %rcx
cmpq %rcx, %rax
jb 0x27575
ja 0x27564
movq 0x40(%r15), %rax
movq 0x40(%r14), %rcx
cmpq %rcx, %rax
jb 0x27575
ja 0x27564
movq 0x38(%r15), %rdx
movq 0x38(%r14), %rsi
xorl %edi, %edi
movq %rdi, %rcx
cmpq %rcx, %rax
je 0x275d1
movb (%rdx,%rcx), %r8b
movb (%rsi,%rcx), %r9b
cmpb %r9b, %r8b
jl 0x275ce
leaq 0x1(%rcx), %rdi
cmpb %r8b, %r9b
jge 0x275ac
xorl %edi, %edi
jmp 0x275d1
movb $0x1, %dil
cmpq %rax, %rcx
setb %bl
andb %dil, %bl
jmp 0x27575
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21c00
movq 0x58(%rbx), %rax
movq %rax, 0x58(%r14)
leaq 0x38(%rbx), %rsi
leaq 0x38(%r14), %rdi
callq 0x41a0
movq 0x60(%rbx), %rax
movq %rax, 0x60(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop