LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_signed() const
long long ParseConstant::get_signed() const {
    switch (type) {
        case C_SIGNED:
            return *(long long *) value;
        case C_UNSIGNED:
            return *(unsigned long long *) value;
        case C_FLOAT:
            return (long long) *(long double *) value;
        case C_BOOL:
            return (long long) *(bool *) value;
        case C_STRING:
        case C_UNDEFINED:
            break;
    }
    printf("ParseConstant::get_signed(): 警告 : 试图获取非法常量值\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x5, %rax
ja 0x693aa
movq -0x28(%rbp), %rax
leaq 0x27399(%rip), %rcx     # 0x906d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x693c0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x693c0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
fldt (%rax)
fnstcw -0x1a(%rbp)
movzwl -0x1a(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x1c(%rbp)
fldcw -0x1c(%rbp)
fistpll -0x18(%rbp)
fldcw -0x1a(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x693c0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
jmp 0x693c0
jmp 0x693aa
leaq 0x274b4(%rip), %rdi     # 0x90865
movb $0x0, %al
callq 0x4080
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_unsigned() const
unsigned long long ParseConstant::get_unsigned() const {
    switch (type) {
        case C_SIGNED:
            return (unsigned long long) *(long long *) value;
        case C_UNSIGNED:
            return *(unsigned long long *) value;
        case C_FLOAT:
            return (unsigned long long) *(long double *) value;
        case C_BOOL:
            return (unsigned long long) *(bool *) value;
        case C_STRING:
        case C_UNDEFINED:
            break;
    }
    printf("ParseConstant::get_unsigned(): 警告 : 试图获取非法常量值\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x5, %rax
ja 0x69491
movq -0x28(%rbp), %rax
leaq 0x272ed(%rip), %rcx     # 0x906ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x694a7
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x694a7
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
fldt (%rax)
flds 0x273bb(%rip)           # 0x907f8
fucomi %st(1), %st
setbe %al
fldz
fcmovbe %st(1), %st
fstp %st(1)
fsubrp %st, %st(1)
fnstcw -0x1a(%rbp)
movzwl -0x1a(%rbp), %ecx
orl $0xc00, %ecx            # imm = 0xC00
movw %cx, -0x1c(%rbp)
fldcw -0x1c(%rbp)
fistpll -0x18(%rbp)
fldcw -0x1a(%rbp)
movzbl %al, %eax
movl %eax, %ecx
shlq $0x3f, %rcx
movq -0x18(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x694a7
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
jmp 0x694a7
jmp 0x69491
leaq 0x27410(%rip), %rdi     # 0x908a8
movb $0x0, %al
callq 0x4080
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_float() const
long double ParseConstant::get_float() const {
    switch (type) {
        case C_SIGNED:
            return *(long long *) value;
        case C_UNSIGNED:
            return *(unsigned long long *) value;
        case C_FLOAT:
            return *(long double *) value;
        case C_BOOL:
            return (long double) *(bool *) value;
        case C_STRING:
        case C_UNDEFINED:
            break;
    }
    printf("ParseConstant::get_float(): 警告 : 试图获取非法常量值\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl (%rax), %eax
movq %rax, -0x38(%rbp)
subq $0x5, %rax
ja 0x69569
movq -0x38(%rbp), %rax
leaq 0x27215(%rip), %rcx     # 0x90704
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
fildll -0x30(%rbp)
fstpt -0x10(%rbp)
jmp 0x6957c
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
testq %rax, %rax
sets %al
movzbl %al, %eax
movl %eax, %ecx
fildll -0x28(%rbp)
leaq 0x272cd(%rip), %rax     # 0x90800
flds (%rax,%rcx,4)
faddp %st, %st(1)
fstpt -0x10(%rbp)
jmp 0x6957c
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
fldt (%rax)
fstpt -0x10(%rbp)
jmp 0x6957c
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, -0x1a(%rbp)
filds -0x1a(%rbp)
fstpt -0x10(%rbp)
jmp 0x6957c
jmp 0x69569
leaq 0x2737d(%rip), %rdi     # 0x908ed
xorl %eax, %eax
callq 0x4080
fldz
fstpt -0x10(%rbp)
fldt -0x10(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_bool() const
bool ParseConstant::get_bool() const {
    switch (type) {
        case C_SIGNED:
            return (bool) *(long long *) value;
        case C_UNSIGNED:
            return (bool) *(unsigned long long *) value;
        case C_FLOAT:
            return (bool) *(long double *) value;
        case C_BOOL:
            return *(bool *) value;
        case C_STRING:
        case C_UNDEFINED:
            break;
    }
    printf("ParseConstant::get_bool(): 警告 : 试图获取非法常量值\n");
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x69622
movq -0x18(%rbp), %rax
leaq 0x27161(%rip), %rcx     # 0x9071c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, (%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x69634
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, (%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x69634
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
fldt (%rax)
fldz
fucompi %st(1), %st
fstp %st(0)
setp %cl
setne %al
orb %cl, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x69634
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x69634
jmp 0x69622
leaq 0x27306(%rip), %rdi     # 0x9092f
movb $0x0, %al
callq 0x4080
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_string[abi:cxx11]() const
string ParseConstant::get_string() const {
    if (type != C_STRING) {
        printf("ParseConstant::get_string(): 警告 : 试图获取非法常量值\n");
        return "";
    }
    return *(string *) value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, (%rax)
je 0x696bb
leaq 0x27301(%rip), %rdi     # 0x90970
xorl %eax, %eax
callq 0x4080
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x45f0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x28194(%rip), %rsi     # 0x91826
callq 0x4450
jmp 0x69699
leaq -0x11(%rbp), %rdi
callq 0x4380
jmp 0x696cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x4380
jmp 0x696d6
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4190
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x45e0
nop
// File: acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::~ParseConstant()
ParseConstant::~ParseConstant() {
    switch (type) {
        case C_STRING:
            delete (string *) value;
            break;
        case C_SIGNED:
            delete (long long *) value;
            break;
        case C_UNSIGNED:
            delete (unsigned *) value;
            break;
        case C_FLOAT:
            delete (long double *) value;
            break;
        case C_BOOL:
            delete (bool *) value;
            break;
        case C_UNDEFINED:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x5, %rax
ja 0x697b4
movq -0x10(%rbp), %rax
leaq 0x27025(%rip), %rcx     # 0x90734
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6973c
movq -0x20(%rbp), %rdi
callq 0x4688
movq -0x20(%rbp), %rdi
callq 0x42d0
jmp 0x697b4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x69759
movq -0x28(%rbp), %rdi
callq 0x42d0
jmp 0x697b4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x69776
movq -0x30(%rbp), %rdi
callq 0x42d0
jmp 0x697b4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x69793
movq -0x38(%rbp), %rdi
callq 0x42d0
jmp 0x697b4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x697b0
movq -0x40(%rbp), %rdi
callq 0x42d0
jmp 0x697b4
jmp 0x697b4
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_const_type_name[abi:cxx11](ConstValueType)
string ParseConstant::get_const_type_name(ConstValueType _type) {
    switch (_type) {
        case C_STRING:
            return "const_string";
        case C_SIGNED:
            return "const_signed_int";
        case C_UNSIGNED:
            return "const_unsigned_int";
        case C_FLOAT:
            return "const_float";
        case C_BOOL:
            return "const_bool";
        case C_UNDEFINED:
            break;
    }
    return "undefined";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x5, %rax
ja 0x69972
movq -0x30(%rbp), %rax
leaq 0x26f56(%rip), %rcx     # 0x9074c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0xd(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x45f0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x27198(%rip), %rsi     # 0x909b3
callq 0x4450
jmp 0x69822
leaq -0xd(%rbp), %rdi
callq 0x4380
jmp 0x699b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x4380
jmp 0x699c1
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x45f0
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x2715a(%rip), %rsi     # 0x909c0
callq 0x4450
jmp 0x6986d
leaq -0x1d(%rbp), %rdi
callq 0x4380
jmp 0x699b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x4380
jmp 0x699c1
leaq -0x1e(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x45f0
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x27120(%rip), %rsi     # 0x909d1
callq 0x4450
jmp 0x698b8
leaq -0x1e(%rbp), %rdi
callq 0x4380
jmp 0x699b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x4380
jmp 0x699c1
leaq -0x1f(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x45f0
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x270e8(%rip), %rsi     # 0x909e4
callq 0x4450
jmp 0x69903
leaq -0x1f(%rbp), %rdi
callq 0x4380
jmp 0x699b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1f(%rbp), %rdi
callq 0x4380
jmp 0x699c1
leaq -0x20(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x45f0
movq -0x40(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x270a9(%rip), %rsi     # 0x909f0
callq 0x4450
jmp 0x6994e
leaq -0x20(%rbp), %rdi
callq 0x4380
jmp 0x699b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4380
jmp 0x699c1
jmp 0x69972
leaq -0x21(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x45f0
movq -0x40(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0x26952(%rip), %rsi     # 0x902e0
callq 0x4450
jmp 0x69995
leaq -0x21(%rbp), %rdi
callq 0x4380
jmp 0x699b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x4380
jmp 0x699c1
movq -0x38(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x45e0
nopw (%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::get_symbol_dec_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
DeclarationType ParseScope::get_symbol_dec_type(const string &symbol) const {
    auto it = symbol2dec_ptr.find(symbol);
    if (it == symbol2dec_ptr.end()) {
        if (parent_scope == this_scope) {
            // 找不到变量声明
            return D_UNKNOWN;
        }
        return get_scope(parent_scope).get_symbol_dec_type(symbol);
    }
    return it->second.first;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x6cbe0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x10, %rdi
callq 0x6cc40
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6cc10
testb $0x1, %al
jne 0x6a80d
jmp 0x6a840
movq -0x30(%rbp), %rcx
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
jne 0x6a823
movl $0x0, -0x4(%rbp)
jmp 0x6a84f
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x6a860
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x6a7c0
movl %eax, -0x4(%rbp)
jmp 0x6a84f
leaq -0x20(%rbp), %rdi
callq 0x6cc70
movl 0x20(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::get_scope(unsigned long)
ParseScope &ParseScope::get_scope(size_t scope_id) {
    if (scopes.empty()) {
        init();
    }
    if (scope_id >= scopes.size()) {
        return scopes[0];
    }
    return scopes[scope_id];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x5cbcd(%rip), %rdi     # 0xc7440
callq 0x6d580
testb $0x1, %al
jne 0x6a87e
jmp 0x6a883
callq 0x6c640
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x5cbae(%rip), %rdi     # 0xc7440
callq 0x6d5c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jb 0x6a8b9
leaq 0x5cb96(%rip), %rdi     # 0xc7440
xorl %eax, %eax
movl %eax, %esi
callq 0x6d480
movq %rax, -0x8(%rbp)
jmp 0x6a8cd
movq -0x10(%rbp), %rsi
leaq 0x5cb7c(%rip), %rdi     # 0xc7440
callq 0x6d480
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::declaration(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ParseType const&)
void ParseScope::declaration(const string &symbol, const ParseType &type) {
    if (symbol.empty()) {
        printf("ParseDeclaration(const string &symbol, const ParseType &type): 警告: 试图声明空符号\n");
        return;
    }
    auto it = symbol2dec_ptr.find(symbol);
    if (it != symbol2dec_ptr.end()) {
        printf("ParseDeclaration(const string &symbol, const ParseVariable &variable): 警告: 试图重声明符号"
               "%s 为 类型:%s 跳过该操作\n", symbol.c_str(), type.get_info().c_str());
        return;
    }
    vector<size_t> type_id;
    type_id.emplace_back(type.get_id());
    symbol2dec_ptr[symbol] = pair<DeclarationType, vector<size_t> >(D_TYPE, type_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4590
testb $0x1, %al
jne 0x6a911
jmp 0x6a924
leaq 0x261b8(%rip), %rdi     # 0x90ad0
movb $0x0, %al
callq 0x4080
jmp 0x6aa72
movq -0xa8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x6cc90
movq -0xa8(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x10, %rdi
callq 0x6ccf0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6ccc0
testb $0x1, %al
jne 0x6a963
jmp 0x6a9d5
movq -0x10(%rbp), %rdi
callq 0x4180
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x566e0
movq -0xb8(%rbp), %rdi
callq 0x4180
movq -0xb0(%rbp), %rsi
movq %rax, %rdx
leaq 0x2618a(%rip), %rdi     # 0x90b2e
xorl %eax, %eax
callq 0x4080
jmp 0x6a9ad
leaq -0x48(%rbp), %rdi
callq 0x4688
jmp 0x6aa72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4688
jmp 0x6aaaa
leaq -0x70(%rbp), %rdi
callq 0x16700
movq -0x18(%rbp), %rdi
callq 0x56260
movq %rax, -0xc0(%rbp)
jmp 0x6a9f0
movq -0xc0(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x35a60
jmp 0x6aa0a
movl $0x3, -0x9c(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0x9c(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x6cd20
jmp 0x6aa2d
movq -0xa8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x6cd60
movq %rax, -0xc8(%rbp)
jmp 0x6aa4a
movq -0xc8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x6ce40
leaq -0x98(%rbp), %rdi
callq 0x6ce80
leaq -0x70(%rbp), %rdi
callq 0x166a0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x6aaa1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x6ce80
leaq -0x70(%rbp), %rdi
callq 0x166a0
movq -0x50(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::declaration(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ParseVariable const&)
void ParseScope::declaration(const string &symbol, const ParseVariable &variable) {
    if (symbol.empty()) {
        printf("ParseDeclaration(const string &symbol, const ParseVariable &variable): 警告: 试图声明空符号\n");
        return;
    }
    auto it = symbol2dec_ptr.find(symbol);
    if (it != symbol2dec_ptr.end()) {
        printf("ParseDeclaration(const string &symbol, const ParseVariable &variable): 警告: 试图重声明符号"
               "%s 为 变量:%s 跳过该操作\n", symbol.c_str(), variable.get_info().c_str());
        return;
    }
    vector<size_t> var_ptr;
    var_ptr.emplace_back((size_t) new ParseVariable(variable));
    symbol2dec_ptr[symbol] = pair<DeclarationType, vector<size_t> >(D_VARIABLE, var_ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4590
testb $0x1, %al
jne 0x6aaf1
jmp 0x6ab04
leaq 0x260bc(%rip), %rdi     # 0x90bb4
movb $0x0, %al
callq 0x4080
jmp 0x6ac65
movq -0xa8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x6cc90
movq -0xa8(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x10, %rdi
callq 0x6ccf0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6ccc0
testb $0x1, %al
jne 0x6ab43
jmp 0x6abb5
movq -0x10(%rbp), %rdi
callq 0x4180
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x684c0
movq -0xb8(%rbp), %rdi
callq 0x4180
movq -0xb0(%rbp), %rsi
movq %rax, %rdx
leaq 0x26096(%rip), %rdi     # 0x90c1a
xorl %eax, %eax
callq 0x4080
jmp 0x6ab8d
leaq -0x48(%rbp), %rdi
callq 0x4688
jmp 0x6ac65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4688
jmp 0x6acb7
leaq -0x70(%rbp), %rdi
callq 0x16700
movl $0x68, %edi
callq 0x4310
movq %rax, -0xc0(%rbp)
jmp 0x6abd1
movq -0xc0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x68a40
jmp 0x6abe3
movq -0xc0(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x35a60
jmp 0x6abfd
movl $0x2, -0x9c(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0x9c(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x6cd20
jmp 0x6ac20
movq -0xa8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x6cd60
movq %rax, -0xc8(%rbp)
jmp 0x6ac3d
movq -0xc8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x6ce40
leaq -0x98(%rbp), %rdi
callq 0x6ce80
leaq -0x70(%rbp), %rdi
callq 0x166a0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x6acae
movq -0xc0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x42d0
jmp 0x6acae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x6ce80
leaq -0x70(%rbp), %rdi
callq 0x166a0
movq -0x50(%rbp), %rdi
callq 0x45e0
// File: acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::init()
void ParseScope::init() {
    scopes.emplace_back(0);
    ParseScope &static_scope = scopes[0];
    vector<size_t> ptr;
    ptr.emplace_back(0);
    // 默认
    static_scope.symbol2dec_ptr[string()] = pair<DeclarationType, vector<size_t> >(D_UNKNOWN, ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x5ade7(%rip), %rdi     # 0xc7440
movq %rdi, -0x98(%rbp)
leaq -0x4(%rbp), %rsi
callq 0x6d410
movq -0x98(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6d480
movq %rax, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x16700
movq -0x90(%rbp), %rdi
movl $0x0, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x65100
jmp 0x6c6a6
movl $0x0, -0x64(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x64(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x6cd20
jmp 0x6c6c0
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0xb0(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4460
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x6d4a0
movq %rax, -0xa0(%rbp)
jmp 0x6c6fe
movq -0xa0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x6ce40
leaq -0x88(%rbp), %rdi
callq 0x4688
leaq -0x60(%rbp), %rdi
callq 0x6ce80
leaq -0x28(%rbp), %rdi
callq 0x166a0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x6c764
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4688
leaq -0x60(%rbp), %rdi
callq 0x6ce80
leaq -0x28(%rbp), %rdi
callq 0x166a0
movq -0x38(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::new_scope(unsigned long)
size_t ParseScope::new_scope(size_t parent) {
    if (scopes.empty()) {
        init();
    }
    if (parent >= scopes.size()) {
        printf("ParseDeclaration::new_scope(size_t parent): 警告: 试图获取不存在的作用域%zu\n", parent);
        return 0;
    }
    scopes.emplace_back(parent);
    scopes[scopes.size() - 1].this_scope = scopes.size() - 1;
    return scopes.size() - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x5acad(%rip), %rdi     # 0xc7440
callq 0x6d580
testb $0x1, %al
jne 0x6c79e
jmp 0x6c7a3
callq 0x6c640
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x5ac8e(%rip), %rdi     # 0xc7440
callq 0x6d5c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jb 0x6c7df
movq -0x10(%rbp), %rsi
leaq 0x24920(%rip), %rdi     # 0x910ee
movb $0x0, %al
callq 0x4080
movq $0x0, -0x8(%rbp)
jmp 0x6c83e
leaq 0x5ac5a(%rip), %rdi     # 0xc7440
leaq -0x10(%rbp), %rsi
callq 0x6d5e0
leaq 0x5ac4a(%rip), %rdi     # 0xc7440
callq 0x6d5c0
subq $0x1, %rax
movq %rax, -0x20(%rbp)
leaq 0x5ac36(%rip), %rdi     # 0xc7440
callq 0x6d5c0
movq %rax, %rsi
subq $0x1, %rsi
leaq 0x5ac23(%rip), %rdi     # 0xc7440
callq 0x6d480
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
leaq 0x5ac0f(%rip), %rdi     # 0xc7440
callq 0x6d5c0
subq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::~ParseScope()
ParseScope::~ParseScope() {
    for (const auto &each : symbol2dec_ptr) {
        switch (each.second.first) {
            case D_UNKNOWN:
            case D_TYPE:
                break;
            case D_FUNCTION:
                for (const auto &each_ptr : each.second.second) {
                    delete (ParseFunction *) (each_ptr);
                }
                break;
            case D_VARIABLE:
                for (const auto &each_ptr : each.second.second) {
                    delete (ParseVariable *) (each_ptr);
                }
                break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6d690
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6ccf0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6ccc0
testb $0x1, %al
jne 0x6c89f
jmp 0x6c9ee
leaq -0x18(%rbp), %rdi
callq 0x6d6c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x78(%rbp)
subq $0x3, %rax
ja 0x6c9de
movq -0x78(%rbp), %rax
leaq 0x23f18(%rip), %rcx     # 0x907e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x6c9de
movq -0x28(%rbp), %rax
addq $0x20, %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1a560
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1a590
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x40110
testb $0x1, %al
jne 0x6c917
jmp 0x6c954
leaq -0x38(%rbp), %rdi
callq 0x40150
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x6c947
movq -0x80(%rbp), %rdi
callq 0x16bc0
movq -0x80(%rbp), %rdi
callq 0x42d0
jmp 0x6c949
leaq -0x38(%rbp), %rdi
callq 0x40170
jmp 0x6c904
jmp 0x6c9de
movq -0x28(%rbp), %rax
addq $0x20, %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1a560
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1a590
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x40110
testb $0x1, %al
jne 0x6c996
jmp 0x6c9dc
leaq -0x58(%rbp), %rdi
callq 0x40150
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0x6c9cf
movq -0x88(%rbp), %rdi
callq 0x16210
movq -0x88(%rbp), %rdi
callq 0x42d0
jmp 0x6c9d1
leaq -0x58(%rbp), %rdi
callq 0x40170
jmp 0x6c983
jmp 0x6c9de
jmp 0x6c9e0
leaq -0x18(%rbp), %rdi
callq 0x6d6e0
jmp 0x6c889
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
callq 0x6cbc0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseScope::get_all_dec_symbol[abi:cxx11]() const
vector<string> ParseScope::get_all_dec_symbol() const {
    vector<string> list;
    for (const auto &each : symbol2dec_ptr) {
        if (each.first.empty()) {
            continue;
        }
        list.emplace_back(each.first);
    }
    return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1da30
movq -0x50(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6d040
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6cc40
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6d070
testb $0x1, %al
jne 0x6caa5
jmp 0x6caf6
leaq -0x28(%rbp), %rdi
callq 0x6d0a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4590
testb $0x1, %al
jne 0x6cac1
jmp 0x6cac3
jmp 0x6cad4
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x6d710
jmp 0x6cad2
jmp 0x6cad4
leaq -0x28(%rbp), %rdi
callq 0x6d0c0
jmp 0x6ca92
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x17430
jmp 0x6cb13
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x6cb09
movq -0x60(%rbp), %rdi
callq 0x17430
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x45e0
nopl (%rax)
// File: acliusBackHome[P]kamaya/dist/ParseTreeErrorHandle.cpp
// Function: ParseTree::native_root(unsigned long)
size_t ParseTree::native_root(size_t idx) {
    size_t p = idx, last;
    while (get_parent(p) != (size_t) (-1)) {
        last = p;
        p = get_parent(p);
        if (p == last) {
            return p;
        }
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x32030
cmpq $-0x1, %rax
je 0x72d12
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
callq 0x32030
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x72d10
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x72d1a
jmp 0x72cd0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseTreeErrorHandle.cpp
// Function: ParseTree::watch_children_nodes() const
void ParseTree::watch_children_nodes() const {
    printf("node_children[%zu]\n", node_children.size());
    for (int i = 0; i < node_children.size(); i++) {
        printf("node_children[%i] size %zu: ", i, node_children[i].size());
        for (auto j : node_children[i]) {
            printf("%zu ", j);
        }
        printf("\n");
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x60, %rdi
callq 0x363b0
movq %rax, %rsi
leaq 0x1e466(%rip), %rdi     # 0x911bd
movb $0x0, %al
callq 0x4080
movl $0x0, -0xc(%rbp)
movq -0x38(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x60, %rdi
callq 0x363b0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x72e48
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
addq $0x60, %rdi
movslq -0xc(%rbp), %rsi
callq 0x34320
movq %rax, %rdi
callq 0x16570
movl -0x44(%rbp), %esi
movq %rax, %rdx
leaq 0x1e41b(%rip), %rdi     # 0x911d1
movb $0x0, %al
callq 0x4080
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
movslq -0xc(%rbp), %rsi
callq 0x34320
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a560
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a590
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x40110
testb $0x1, %al
jne 0x72dff
jmp 0x72e2c
leaq -0x20(%rbp), %rdi
callq 0x40150
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq 0x1cfea(%rip), %rdi     # 0x8fe04
movb $0x0, %al
callq 0x4080
leaq -0x20(%rbp), %rdi
callq 0x40170
jmp 0x72dec
leaq 0x1c4f6(%rip), %rdi     # 0x8f329
movb $0x0, %al
callq 0x4080
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x72d65
leaq 0x1c4da(%rip), %rdi     # 0x8f329
movb $0x0, %al
callq 0x4080
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: acliusBackHome[P]kamaya/dist/ParseTreeErrorHandle.cpp
// Function: ParseTree::watch_last_nodes() const
void ParseTree::watch_last_nodes() const {
    printf("last_nodes[%zu]\n", last_nodes.size());
    for (auto i : last_nodes) {
        printf("%zu %s\n", i, get_msg(i).c_str());
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x78, %rdi
callq 0x734a0
movq %rax, %rsi
leaq 0x1e367(%rip), %rdi     # 0x911ee
movb $0x0, %al
callq 0x4080
movq -0x60(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x73410
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x341a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x34130
testb $0x1, %al
jne 0x72ec7
jmp 0x72f3b
leaq -0x18(%rbp), %rdi
callq 0x73440
movq -0x60(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq %rdx, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x31c50
movq -0x70(%rbp), %rdi
callq 0x4180
movq -0x68(%rbp), %rsi
movq %rax, %rdx
leaq 0x1e2f8(%rip), %rdi     # 0x911ff
xorl %eax, %eax
callq 0x4080
jmp 0x72f10
leaq -0x48(%rbp), %rdi
callq 0x4688
leaq -0x18(%rbp), %rdi
callq 0x73470
jmp 0x72eb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4688
jmp 0x72f4f
leaq 0x1c3e7(%rip), %rdi     # 0x8f329
movb $0x0, %al
callq 0x4080
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x45e0
nopl (%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseTreeErrorHandle.cpp
// Function: ParseTree::watch_error_nodes() const
void ParseTree::watch_error_nodes() const {
    printf("error_nodes[%zu]\n", error_nodes.size());
    for (auto i : error_nodes) {
        printf("%zu %s\n", i, get_msg(i).c_str());
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x48, %rdi
callq 0x16570
movq %rax, %rsi
leaq 0x1e280(%rip), %rdi     # 0x91207
movb $0x0, %al
callq 0x4080
movq -0x60(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a560
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a590
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x40110
testb $0x1, %al
jne 0x72fc7
jmp 0x7303b
leaq -0x18(%rbp), %rdi
callq 0x40150
movq -0x60(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq %rdx, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x31c50
movq -0x70(%rbp), %rdi
callq 0x4180
movq -0x68(%rbp), %rsi
movq %rax, %rdx
leaq 0x1e1f8(%rip), %rdi     # 0x911ff
xorl %eax, %eax
callq 0x4080
jmp 0x73010
leaq -0x48(%rbp), %rdi
callq 0x4688
leaq -0x18(%rbp), %rdi
callq 0x40170
jmp 0x72fb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4688
jmp 0x7304f
leaq 0x1c2e7(%rip), %rdi     # 0x8f329
movb $0x0, %al
callq 0x4080
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x45e0
nopl (%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseException.cpp
// Function: ParseException::get_info[abi:cxx11]() const
string ParseException::get_info() const {
    string temp_what = "ParseException {\n  code:";
    temp_what += get_code_msg(code) + ",\n";
    for (const auto &each : trace) {
        temp_what += "  " + each + ",\n";
    }
    temp_what += "}";
    return temp_what;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x45f0
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rdx
leaq 0x1d6e5(%rip), %rsi     # 0x9128d
callq 0x4450
jmp 0x73baf
leaq -0x12(%rbp), %rdi
callq 0x4380
movq -0xe0(%rbp), %rax
movl 0x8(%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x73db0
jmp 0x73bcd
leaq 0x1dc4d(%rip), %rdx     # 0x91821
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x15ed0
jmp 0x73be3
movq -0xd8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x43f0
jmp 0x73bf5
leaq -0x48(%rbp), %rdi
callq 0x4688
leaq -0x68(%rbp), %rdi
callq 0x4688
movq -0xe0(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x2bfd0
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
callq 0x2c000
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x746c0
testb $0x1, %al
jne 0x73c46
jmp 0x73d56
leaq -0x78(%rbp), %rdi
callq 0x74700
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdx
leaq 0x1ba72(%rip), %rsi     # 0x8f6d6
leaq -0xc8(%rbp), %rdi
callq 0x16320
jmp 0x73c72
leaq 0x1dba8(%rip), %rdx     # 0x91821
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x15ed0
jmp 0x73c8e
movq -0xd8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x43f0
jmp 0x73ca3
leaq -0xa8(%rbp), %rdi
callq 0x4688
leaq -0xc8(%rbp), %rdi
callq 0x4688
leaq -0x78(%rbp), %rdi
callq 0x74720
jmp 0x73c30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x4380
jmp 0x73d9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x73d91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x73d17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4688
leaq -0x68(%rbp), %rdi
callq 0x4688
jmp 0x73d91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x73d48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x4688
leaq -0xc8(%rbp), %rdi
callq 0x4688
jmp 0x73d91
movq -0xd8(%rbp), %rdi
leaq 0x1c504(%rip), %rsi     # 0x90268
callq 0x42e0
jmp 0x73d6b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x73d81
movq -0xd8(%rbp), %rdi
callq 0x4688
movq -0xe8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x4688
movq -0x20(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseException.cpp
// Function: ParseException::what() const
const char *ParseException::what() const noexcept {
    const string &info = get_info();
    char *temp = new char[get_info().length() + 1];
    strcpy(temp, get_info().c_str());
    return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x73b50
jmp 0x74582
movq -0x80(%rbp), %rsi
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x73b50
jmp 0x74599
leaq -0x58(%rbp), %rdi
callq 0x44e0
movq %rax, %rdi
incq %rdi
callq 0x4030
movq %rax, -0x88(%rbp)
jmp 0x745b6
leaq -0x58(%rbp), %rdi
callq 0x4688
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x73b50
jmp 0x745e4
leaq -0x78(%rbp), %rdi
callq 0x4180
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x42c0
leaq -0x78(%rbp), %rdi
callq 0x4688
movq -0x38(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4688
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x16180
nopw %cs:(%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/ParseExpressionConstCalculate.cpp
// Function: ParseExpression::calculate_const_add(ConstValueType, ParseConstant const&, ParseConstant const&)
void ParseExpression::
calculate_const_add(ConstValueType cal_type,
                    const ParseConstant &const1, const ParseConstant &const2) {
    switch (cal_type) {
        case C_BOOL:
        case C_SIGNED: {
            const_value = (size_t)
                    new ParseConstant(const1.get_signed() + const2.get_signed());
            return;
        }
        case C_UNSIGNED: {
            const_value = (size_t)
                    new ParseConstant(const1.get_unsigned() + const2.get_unsigned());
            return;
        }
        case C_FLOAT: {
            const_value = (size_t)
                    new ParseConstant(const1.get_float() + const2.get_float());
            return;
        }
        case C_STRING:
        default:
            break;
    }
    const_value = (size_t) -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x4, %rax
ja 0x753bc
movq -0x38(%rbp), %rax
leaq 0x1c3ea(%rip), %rcx     # 0x91648
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x10, %edi
callq 0x4310
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x69310
movq %rax, -0x48(%rbp)
jmp 0x75284
movq -0x20(%rbp), %rdi
callq 0x69310
movq %rax, -0x58(%rbp)
jmp 0x75293
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rsi
addq %rax, %rsi
callq 0x69180
jmp 0x752a9
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x753ca
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x42d0
jmp 0x753d3
movl $0x10, %edi
callq 0x4310
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x693d0
movq %rax, -0x60(%rbp)
jmp 0x752f1
movq -0x20(%rbp), %rdi
callq 0x693d0
movq %rax, -0x70(%rbp)
jmp 0x75300
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rax
movq -0x60(%rbp), %rsi
addq %rax, %rsi
callq 0x691c0
jmp 0x75316
movq -0x40(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x753ca
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x42d0
jmp 0x753d3
movl $0x10, %edi
callq 0x4310
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
callq 0x694c0
fstpt -0x7c(%rbp)
jmp 0x75360
movq -0x20(%rbp), %rdi
callq 0x694c0
fstpt -0x94(%rbp)
jmp 0x75371
movq -0x88(%rbp), %rdi
fldt -0x7c(%rbp)
fldt -0x94(%rbp)
faddp %st, %st(1)
movq %rsp, %rax
fstpt (%rax)
callq 0x69250
jmp 0x7538f
movq -0x40(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x753ca
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x42d0
jmp 0x753d3
jmp 0x753bc
jmp 0x753be
movq -0x40(%rbp), %rax
movq $-0x1, 0x18(%rax)
addq $0xb0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x45e0
nopl (%rax)
// File: acliusBackHome[P]kamaya/dist/ParseExpressionConstCalculate.cpp
// Function: ParseExpression::calculate_const_neg(ConstValueType, ParseConstant const&)
void ParseExpression::calculate_const_neg(ConstValueType cal_type, const ParseConstant &constant) {
    switch (cal_type) {
        case C_BOOL:
        case C_SIGNED: {
            const_value = (size_t)
                    new ParseConstant(-constant.get_signed());
            return;
        }
        case C_UNSIGNED: {
            const_value = (size_t)
                    new ParseConstant(-constant.get_unsigned());
            return;
        }
        case C_FLOAT: {
            const_value = (size_t)
                    new ParseConstant(-constant.get_float());
            return;
        }
        case C_STRING:
        default:
            break;
    }
    const_value = (size_t) -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x4, %rax
ja 0x76df9
movq -0x30(%rbp), %rax
leaq 0x1aa3a(%rip), %rcx     # 0x91724
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x10, %edi
callq 0x4310
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x69310
movq %rax, -0x40(%rbp)
jmp 0x76d10
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
negq %rsi
callq 0x69180
jmp 0x76d22
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x76e07
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x42d0
jmp 0x76e10
movl $0x10, %edi
callq 0x4310
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x693d0
movq %rax, -0x50(%rbp)
jmp 0x76d6a
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
negq %rsi
callq 0x691c0
jmp 0x76d7c
movq -0x38(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x76e07
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x42d0
jmp 0x76e10
movl $0x10, %edi
callq 0x4310
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x694c0
fstpt -0x64(%rbp)
jmp 0x76dbd
movq -0x70(%rbp), %rdi
fldt -0x64(%rbp)
fchs
movq %rsp, %rax
fstpt (%rax)
callq 0x69250
jmp 0x76dd2
movq -0x38(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x76e07
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x42d0
jmp 0x76e10
jmp 0x76df9
jmp 0x76dfb
movq -0x38(%rbp), %rax
movq $-0x1, 0x18(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x45e0
nopl (%rax)
// File: acliusBackHome[P]kamaya/dist/x86.cpp
// Function: x86::Assembler::getWideStr[abi:cxx11](unsigned long)
string Assembler::getWideStr(size_t size) {
  if (wideMap.find(size) == wideMap.end()) {
    log("IN getWide: ERROR SIZE " + to_string(size));
    return "BadWide";
  }
  return wideMap[size];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x40, %rdi
leaq -0x18(%rbp), %rsi
callq 0x497f0
movq -0x80(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x40, %rdi
callq 0x49850
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x29e80
testb $0x1, %al
jne 0x7c4a8
jmp 0x7c572
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x15db0
movq -0x98(%rbp), %rdx
leaq 0x1535d(%rip), %rsi     # 0x91827
leaq -0x48(%rbp), %rdi
callq 0x15d60
jmp 0x7c4d5
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x7c5b0
jmp 0x7c4e4
leaq -0x48(%rbp), %rdi
callq 0x4688
leaq -0x68(%rbp), %rdi
callq 0x4688
leaq -0x75(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x45f0
movq -0x90(%rbp), %rdi
movq -0xa0(%rbp), %rdx
leaq 0x15324(%rip), %rsi     # 0x9183f
callq 0x4450
jmp 0x7c522
leaq -0x75(%rbp), %rdi
callq 0x4380
jmp 0x7c592
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7c550
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4688
leaq -0x68(%rbp), %rdi
callq 0x4688
jmp 0x7c5a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x75(%rbp), %rdi
callq 0x4380
jmp 0x7c5a2
movq -0x80(%rbp), %rdi
addq $0x40, %rdi
leaq -0x18(%rbp), %rsi
callq 0x80a70
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x4190
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x45e0
nopl (%rax,%rax)