LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: acliusBackHome[P]kamaya/dist/ParseTree.cpp
// Function: ParseTree::make_assign_expression_node(ParseExpression const&, ParseExpression const&)
size_t ParseTree::make_assign_expression_node(
        const ParseExpression &l_expr, const ParseExpression &r_expr) {
    const ParseExpression &assign_expr = ParseExpression::get_assign_expression(l_expr, r_expr);
    size_t new_one = new_node(N_EXPRESSION);
    nodes[new_one].set_expression(assign_expr);
    return new_one;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x63880
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movl $0xf, %esi
callq 0x31db0
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x34080
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x3e690
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::get_true_list() const
const vector<size_t> &ParseNode::get_true_list() const {
    // 需求特殊性: 如果没有则先set为空, 再返回之
    if (!(keys & K_TRUE_LIST)) {
        ((ParseNode *) this)->set_true_list(vector<size_t>());
    }
    return get_field<vector<size_t>>(K_TRUE_LIST);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rax), %rax
andq $0x8000, %rax           # imm = 0x8000
cmpq $0x0, %rax
jne 0x3dff1
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x16700
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3e7b0
jmp 0x3dfcf
leaq -0x20(%rbp), %rdi
callq 0x166a0
jmp 0x3dff1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x166a0
jmp 0x3e005
movq -0x38(%rbp), %rdi
movl $0x8000, %esi           # imm = 0x8000
callq 0x46000
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x45e0
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rax), %rax
andq $0x10000, %rax          # imm = 0x10000
cmpq $0x0, %rax
jne 0x3e081
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x16700
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3e7e0
jmp 0x3e05f
leaq -0x20(%rbp), %rdi
callq 0x166a0
jmp 0x3e081
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x166a0
jmp 0x3e095
movq -0x38(%rbp), %rdi
movl $0x10000, %esi          # imm = 0x10000
callq 0x46000
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x45e0
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rax), %rax
andq $0x80000, %rax          # imm = 0x80000
cmpq $0x0, %rax
jne 0x3e171
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x16700
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3e870
jmp 0x3e14f
leaq -0x20(%rbp), %rdi
callq 0x166a0
jmp 0x3e171
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x166a0
jmp 0x3e185
movq -0x38(%rbp), %rdi
movl $0x80000, %esi          # imm = 0x80000
callq 0x46000
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x45e0
nop
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x800000, %esi         # imm = 0x800000
callq 0x3e240
testb $0x1, %al
jne 0x3e9e8
jmp 0x3ea19
movq -0x58(%rbp), %rdi
callq 0x3e200
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63810
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x35a60
jmp 0x3ea80
leaq -0x38(%rbp), %rdi
callq 0x16700
movq -0x10(%rbp), %rdi
callq 0x63810
movq %rax, -0x68(%rbp)
jmp 0x3ea31
movq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x35a60
jmp 0x3ea48
movq -0x58(%rbp), %rdi
movl $0x800000, %esi         # imm = 0x800000
leaq -0x38(%rbp), %rdx
xorl %ecx, %ecx
callq 0x41ee0
jmp 0x3ea5e
leaq -0x38(%rbp), %rdi
callq 0x166a0
jmp 0x3ea80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x166a0
jmp 0x3ea86
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x45e0
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x80, %esi
callq 0x3e240
testb $0x1, %al
jne 0x3eab8
jmp 0x3ead4
movq -0x48(%rbp), %rdi
callq 0x3de50
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x42ab0
jmp 0x3eb28
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x16700
movq -0x50(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x42ab0
jmp 0x3eaf0
movq -0x48(%rbp), %rdi
movl $0x80, %esi
leaq -0x30(%rbp), %rdx
xorl %ecx, %ecx
callq 0x41ee0
jmp 0x3eb06
leaq -0x30(%rbp), %rdi
callq 0x166a0
jmp 0x3eb28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x166a0
jmp 0x3eb2e
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x45e0
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x100, %esi            # imm = 0x100
callq 0x3e240
testb $0x1, %al
jne 0x3eb68
jmp 0x3eb84
movq -0x48(%rbp), %rdi
callq 0x3de70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42b20
jmp 0x3ebd8
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x42b90
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42b20
jmp 0x3eba0
movq -0x48(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
leaq -0x30(%rbp), %rdx
xorl %ecx, %ecx
callq 0x42bb0
jmp 0x3ebb6
leaq -0x30(%rbp), %rdi
callq 0x21ff0
jmp 0x3ebd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x21ff0
jmp 0x3ebde
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x45e0
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x55e14
movq -0x28(%rbp), %rdi
callq 0x20730
movq -0x28(%rbp), %rdi
callq 0x42d0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x55e67
movl $0x30, %edi
callq 0x4310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x59420
jmp 0x55e42
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x55e73
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x42d0
jmp 0x55ee3
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x45e0
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x56648
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x566e0
movq -0x60(%rbp), %rdi
callq 0x4180
movq %rax, %rsi
leaq 0x3983f(%rip), %rdi     # 0x8fe49
xorl %eax, %eax
callq 0x4080
jmp 0x56613
leaq -0x38(%rbp), %rdi
callq 0x4688
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x55d70
jmp 0x566c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4688
jmp 0x566d2
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x5668a
movq -0x10(%rbp), %rdi
callq 0x56d20
movq -0x58(%rbp), %rdi
movq %rax, %rdx
movq -0x18(%rbp), %r9
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %ecx
movl $0x8, %r8d
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x58480
jmp 0x566c8
movq -0x58(%rbp), %rdi
movb $0x0, -0x45(%rbp)
movq -0x10(%rbp), %rsi
callq 0x55d70
movq -0x58(%rbp), %rax
movq $-0x1, 0x18(%rax)
movq -0x18(%rbp), %rcx
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movb $0x1, -0x45(%rbp)
testb $0x1, -0x45(%rbp)
jne 0x566c6
movq -0x58(%rbp), %rdi
callq 0x57350
jmp 0x566c8
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x45e0
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x70615(%rip), %rdi     # 0xc7348
callq 0x59450
testb $0x1, %al
jne 0x56d3e
jmp 0x56d43
callq 0x57750
movq -0x10(%rbp), %rax
cmpq $-0x1, 0x18(%rax)
jne 0x56e3f
movq -0x10(%rbp), %rsi
leaq 0x705bb(%rip), %rdi     # 0xc7318
callq 0x59910
movq %rax, -0x18(%rbp)
leaq 0x705ab(%rip), %rdi     # 0xc7318
callq 0x59970
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x59940
testb $0x1, %al
jne 0x56d8c
jmp 0x56e24
leaq 0x705b5(%rip), %rdi     # 0xc7348
movq %rdi, -0x60(%rbp)
callq 0x59490
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rsi
movq 0x18(%rsi), %rax
movq %rax, -0x68(%rbp)
leaq 0x7055e(%rip), %rdi     # 0xc7318
callq 0x59630
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %rdi
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
callq 0x599a0
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x566e0
movq -0x58(%rbp), %rsi
leaq 0x70571(%rip), %rdi     # 0xc7360
callq 0x2bda0
jmp 0x56df6
leaq -0x40(%rbp), %rdi
callq 0x4688
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x56e4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4688
jmp 0x56e55
leaq -0x18(%rbp), %rdi
callq 0x59a10
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rax, 0x18(%rcx)
movq %rax, -0x8(%rbp)
jmp 0x56e4b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x45e0
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x704d5(%rip), %rdi     # 0xc7348
callq 0x59450
testb $0x1, %al
jne 0x56e7e
jmp 0x56e83
callq 0x57750
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x704b6(%rip), %rdi     # 0xc7348
callq 0x59490
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jb 0x56ecb
movq -0x10(%rbp), %rsi
leaq 0x39001(%rip), %rdi     # 0x8feaf
movb $0x0, %al
callq 0x4080
leaq 0x7048c(%rip), %rdi     # 0xc7348
xorl %eax, %eax
movl %eax, %esi
callq 0x59530
movq %rax, -0x8(%rbp)
jmp 0x56edf
movq -0x10(%rbp), %rsi
leaq 0x70472(%rip), %rdi     # 0xc7348
callq 0x59530
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movl $0x0, (%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x8(%rax)
movq $-0x1, 0x18(%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq 0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq $-0x1, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x5867c
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x34440
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rdi
callq 0x344a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x34470
testb $0x1, %al
jne 0x5864a
jmp 0x58655
movq -0x40(%rbp), %rdi
callq 0x572d0
jmp 0x58685
leaq -0x20(%rbp), %rdi
callq 0x344d0
movq 0x20(%rax), %rsi
leaq 0x6ecdf(%rip), %rdi     # 0xc7348
callq 0x59530
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x55d70
jmp 0x58685
movq -0x40(%rbp), %rdi
callq 0x572d0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, (%rax)
jne 0x586cd
movq -0x18(%rbp), %rdi
callq 0x56260
movq %rax, %rsi
leaq 0x3785c(%rip), %rdi     # 0x8ff18
movb $0x0, %al
callq 0x4080
movq $0x0, -0x8(%rbp)
jmp 0x586d9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x9, -0x10(%rbp)
ja 0x59090
cmpq $0x9, -0x18(%rbp)
ja 0x59090
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
setae %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x590e9
movq -0x10(%rbp), %rdi
callq 0x56e60
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x56e60
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x590d9
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x590d9
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
setge %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x590e9
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
setae %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x665dd(%rip), %rdi     # 0xc7410
callq 0x65270
testb $0x1, %al
jne 0x60e3e
jmp 0x60e43
callq 0x62400
movq -0x8(%rbp), %rsi
leaq 0x66592(%rip), %rdi     # 0xc73e0
callq 0x65300
movq %rax, -0x10(%rbp)
leaq 0x66582(%rip), %rdi     # 0xc73e0
callq 0x65360
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x65330
testb $0x1, %al
jne 0x60e7d
jmp 0x60f0b
leaq 0x6658c(%rip), %rdi     # 0xc7410
callq 0x652b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x66548(%rip), %rdi     # 0xc73e0
callq 0x65390
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
leaq 0x66565(%rip), %rdi     # 0xc7410
callq 0x652b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rsi
leaq 0x6654a(%rip), %rdi     # 0xc7410
callq 0x65470
movl $0x0, -0x1c(%rbp)
leaq 0x6654f(%rip), %rdi     # 0xc7428
leaq -0x1c(%rbp), %rsi
callq 0x65100
leaq 0x66527(%rip), %rdi     # 0xc7410
callq 0x652b0
movq %rax, %rsi
subq $0x1, %rsi
leaq 0x66514(%rip), %rdi     # 0xc7410
callq 0x652e0
movq %rax, %rdi
callq 0x5a80
jmp 0x60f20
leaq -0x10(%rbp), %rdi
callq 0x654e0
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x664cd(%rip), %rdi     # 0xc7410
callq 0x65270
testb $0x1, %al
jne 0x60f4e
jmp 0x60f53
callq 0x62400
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x664ae(%rip), %rdi     # 0xc7410
callq 0x652b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jb 0x60f9b
movq -0x10(%rbp), %rsi
leaq 0x2f3ac(%rip), %rdi     # 0x9032a
movb $0x0, %al
callq 0x4080
leaq 0x66484(%rip), %rdi     # 0xc7410
xorl %eax, %eax
movl %eax, %esi
callq 0x652e0
movq %rax, -0x8(%rbp)
jmp 0x60faf
movq -0x10(%rbp), %rsi
leaq 0x6646a(%rip), %rdi     # 0xc7410
callq 0x652e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x3, 0x28(%rax)
jne 0x617b0
movb $0x1, -0x1(%rbp)
jmp 0x617e6
movq -0x18(%rbp), %rax
cmpq $-0x1, 0x18(%rax)
jne 0x617c1
movb $0x0, -0x1(%rbp)
jmp 0x617e6
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x617d5
movq -0x18(%rbp), %rdi
callq 0x74b60
movq -0x18(%rbp), %rax
cmpq $-0x1, 0x18(%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $-0x1, 0x20(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
movq $0x0, 0x18(%rax)
movl $0x0, 0x28(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x3, 0x28(%rax)
movl $0x10, %edi
callq 0x4310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
callq 0x69010
jmp 0x61eb1
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x562b0
movq -0x78(%rbp), %rdi
callq 0x56260
movq %rax, -0x70(%rbp)
jmp 0x61ee3
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, 0x20(%rax)
leaq -0x58(%rbp), %rdi
callq 0x57350
movq -0x68(%rbp), %rdi
callq 0x60e20
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x42d0
jmp 0x61f36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x57350
movq -0x18(%rbp), %rdi
callq 0x45e0
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x68730
movq %rax, %rdi
callq 0x56260
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x1, 0x28(%rax)
movl $0x68, %edi
callq 0x4310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x68a40
jmp 0x621e2
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, (%rdi)
callq 0x60e20
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x42d0
movq -0x18(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64f60
testb $0x1, %al
jne 0x62250
jmp 0x62316
leaq -0x31(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x45f0
movq -0x90(%rbp), %rdx
leaq 0x2e07c(%rip), %rsi     # 0x902ea
leaq -0x30(%rbp), %rdi
callq 0x4450
jmp 0x62279
leaq -0x31(%rbp), %rdi
callq 0x4380
movl $0x28, %edi
callq 0x41c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movl $0x15, %esi
leaq -0x30(%rbp), %rdx
callq 0x73a90
jmp 0x622a9
movq -0x98(%rbp), %rdi
leaq 0x63a99(%rip), %rsi     # 0xc5d50
leaq -0x4c42e(%rip), %rdx    # 0x15e90
callq 0x45b0
jmp 0x623fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x4380
jmp 0x623f3
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x4280
jmp 0x62308
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4688
jmp 0x623f3
movq -0x88(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x16550
movq (%rax), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x68ac0
movq -0xa8(%rbp), %rdi
callq 0x56260
movq %rax, -0xa0(%rbp)
jmp 0x6235a
movq -0x88(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq %rcx, 0x20(%rax)
leaq -0x80(%rbp), %rdi
callq 0x57350
movq -0x88(%rbp), %rax
movl $0x2, 0x28(%rax)
movl $0x18, %edi
callq 0x4310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x64fa0
jmp 0x623a5
movq -0x88(%rbp), %rdi
movq -0xb0(%rbp), %rax
movq %rax, (%rdi)
callq 0x60e20
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x57350
jmp 0x623f3
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x42d0
movq -0x40(%rbp), %rdi
callq 0x45e0
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x61790
movb %al, -0x9(%rbp)
jmp 0x6282e
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x62837
jmp 0x6285d
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6285b
movq -0x20(%rbp), %rdi
callq 0x696e0
movq -0x20(%rbp), %rdi
callq 0x42d0
jmp 0x6285d
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x19, %rax
ja 0x62906
movq -0x28(%rbp), %rax
leaq 0x2d963(%rip), %rcx     # 0x901e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x628a9
movq -0x30(%rbp), %rdi
callq 0x16240
movq -0x30(%rbp), %rdi
callq 0x42d0
jmp 0x62906
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x628ce
movq -0x38(%rbp), %rdi
callq 0x16210
movq -0x38(%rbp), %rdi
callq 0x42d0
jmp 0x62906
movq -0x18(%rbp), %rcx
movq (%rcx), %rax
cmpq 0x18(%rcx), %rax
je 0x62902
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x62900
movq -0x40(%rbp), %rdi
callq 0x696e0
movq -0x40(%rbp), %rdi
callq 0x42d0
jmp 0x62902
jmp 0x62906
jmp 0x62906
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x16180
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x64ad1(%rip), %rdi     # 0xc7410
callq 0x65270
testb $0x1, %al
jne 0x6294a
jmp 0x6294f
callq 0x62400
movq -0x28(%rbp), %rax
movl $0x1, 0x28(%rax)
movl $0x68, %edi
callq 0x4310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x68a40
jmp 0x62979
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
callq 0x60e20
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x42d0
movq -0x18(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::get_expr_id(ParseExpression 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x63855
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6386a
movq -0x10(%rbp), %rdi
callq 0x60e20
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x74b60
movq -0x68(%rbp), %rdi
callq 0x61790
testb $0x1, %al
jne 0x63e7b
jmp 0x63e8c
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x45f0
movq -0x70(%rbp), %rdx
leaq 0x2c6bc(%rip), %rsi     # 0x90560
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0x63eaf
leaq -0x29(%rbp), %rdi
callq 0x4380
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x60(%rbp), %rdi
callq 0x15db0
jmp 0x63ecb
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x43f0
jmp 0x63eda
leaq -0x60(%rbp), %rdi
callq 0x4688
movl $0x28, %edi
callq 0x41c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movl $0xb, %esi
leaq -0x28(%rbp), %rdx
callq 0x73a90
jmp 0x63f07
movq -0x78(%rbp), %rdi
leaq 0x61e3e(%rip), %rsi     # 0xc5d50
leaq -0x4e089(%rip), %rdx    # 0x15e90
callq 0x45b0
jmp 0x63f83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x4380
jmp 0x63f7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x63f71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4688
jmp 0x63f71
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x4280
leaq -0x28(%rbp), %rdi
callq 0x4688
movq -0x38(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x640c0
testb $0x1, %al
jne 0x63fb2
jmp 0x63fc2
movq -0x68(%rbp), %rax
movq (%rax), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x45f0
movq -0x70(%rbp), %rdx
leaq 0x2c5ac(%rip), %rsi     # 0x90586
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0x63fe5
leaq -0x29(%rbp), %rdi
callq 0x4380
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x60(%rbp), %rdi
callq 0x15db0
jmp 0x64001
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x43f0
jmp 0x64010
leaq -0x60(%rbp), %rdi
callq 0x4688
movl $0x28, %edi
callq 0x41c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movl $0xc, %esi
leaq -0x28(%rbp), %rdx
callq 0x73a90
jmp 0x6403d
movq -0x78(%rbp), %rdi
leaq 0x61d08(%rip), %rsi     # 0xc5d50
leaq -0x4e1bf(%rip), %rdx    # 0x15e90
callq 0x45b0
jmp 0x640b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x4380
jmp 0x640b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x640a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4688
jmp 0x640a7
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x4280
leaq -0x28(%rbp), %rdi
callq 0x4688
movq -0x38(%rbp), %rdi
callq 0x45e0
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x64210
testb $0x1, %al
jne 0x64102
jmp 0x64112
movq -0x68(%rbp), %rax
movq (%rax), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x45f0
movq -0x70(%rbp), %rdx
leaq 0x2c485(%rip), %rsi     # 0x905af
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0x64135
leaq -0x29(%rbp), %rdi
callq 0x4380
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x60(%rbp), %rdi
callq 0x15db0
jmp 0x64151
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x43f0
jmp 0x64160
leaq -0x60(%rbp), %rdi
callq 0x4688
movl $0x28, %edi
callq 0x41c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movl $0xd, %esi
leaq -0x28(%rbp), %rdx
callq 0x73a90
jmp 0x6418d
movq -0x78(%rbp), %rdi
leaq 0x61bb8(%rip), %rsi     # 0xc5d50
leaq -0x4e30f(%rip), %rdx    # 0x15e90
callq 0x45b0
jmp 0x64209
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x4380
jmp 0x64200
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x641f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4688
jmp 0x641f7
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x4280
leaq -0x28(%rbp), %rdi
callq 0x4688
movq -0x38(%rbp), %rdi
callq 0x45e0
nopl (%rax)
// File: 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
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0x108(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x100(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x566e0
movq -0xf8(%rbp), %rdi
movq -0xf0(%rbp), %rdx
leaq 0x282f0(%rip), %rsi     # 0x90808
callq 0x15d60
jmp 0x6851f
leaq -0x38(%rbp), %rdi
callq 0x4688
movq -0x100(%rbp), %rdx
addq $0x38, %rdx
leaq 0x282e4(%rip), %rsi     # 0x9081e
leaq -0x68(%rbp), %rdi
callq 0x16320
jmp 0x68545
movq -0xf8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x43f0
jmp 0x68557
leaq -0x68(%rbp), %rdi
callq 0x4688
movq -0x100(%rbp), %rax
movq 0x58(%rax), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x15db0
jmp 0x68579
leaq 0x282da(%rip), %rsi     # 0x9085a
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rdx
callq 0x15d60
jmp 0x68595
movq -0xf8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x43f0
jmp 0x685aa
leaq -0x88(%rbp), %rdi
callq 0x4688
leaq -0xa8(%rbp), %rdi
callq 0x4688
movq -0x100(%rbp), %rax
movq 0x60(%rax), %rsi
leaq -0xe8(%rbp), %rdi
callq 0x15db0
jmp 0x685db
leaq 0x28246(%rip), %rsi     # 0x90828
leaq -0xc8(%rbp), %rdi
leaq -0xe8(%rbp), %rdx
callq 0x15d60
jmp 0x685f7
movq -0xf8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x43f0
jmp 0x6860c
leaq -0xc8(%rbp), %rdi
callq 0x4688
leaq -0xe8(%rbp), %rdi
callq 0x4688
movq -0xf8(%rbp), %rdi
leaq 0x27c36(%rip), %rsi     # 0x90268
callq 0x42e0
jmp 0x68639
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x68705
jmp 0x686f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4688
jmp 0x68721
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x68715
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4688
jmp 0x68715
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x686b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4688
leaq -0xa8(%rbp), %rdi
callq 0x4688
jmp 0x68715
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x686eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x4688
leaq -0xe8(%rbp), %rdi
callq 0x4688
jmp 0x68715
movq -0xf8(%rbp), %rdi
callq 0x4688
movq -0x108(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xf8(%rbp), %rdi
callq 0x4688
movq -0x40(%rbp), %rdi
callq 0x45e0
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x572a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x58(%rdi)
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
addq $0x38, %rdi
callq 0x4060
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x60(%rcx), %rcx
movq %rcx, 0x60(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x5, %rax
ja 0x69170
movq -0x28(%rbp), %rax
leaq 0x27641(%rip), %rcx     # 0x906bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x20, %edi
callq 0x4310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4190
jmp 0x690a7
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x69170
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x42d0
jmp 0x69176
movl $0x8, %edi
callq 0x4310
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, (%rcx)
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x69170
movl $0x8, %edi
callq 0x4310
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, (%rcx)
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x69170
movl $0x10, %edi
callq 0x4310
movq %rax, %rcx
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rdx
fldt (%rdx)
fstpt (%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x69170
movl $0x1, %edi
callq 0x4310
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, (%rcx)
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x69170
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x45e0
nop