LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/global.cpp
// Function: hexa2bcd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string hexa2bcd(const string &str)
{
    ostringstream bcd;
    int i;

    for (i=0; i<(int)str.size();i+=2)
        bcd << (uchar)strtol((str.substr(i,2).size()==1 ? str.substr(i,2)+"F" : str.substr(i,2)).c_str(),NULL, 16);

    return bcd.str();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4420
cmpl $0x0, 0x8(%r14)
jle 0xca55
leaq 0x18(%rsp), %r12
xorl %r15d, %r15d
leaq 0x50(%rsp), %rbp
movl $0x2, %ecx
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4300
movq 0x38(%rsp), %r13
cmpq $0x1, %r13
jne 0xc992
movl $0x2, %ecx
movq %rbp, %rbx
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4300
movq %rbx, %rdi
leaq 0x9883(%rip), %rsi      # 0x161ed
callq 0x45d0
movq %r12, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xc9a9
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xc9b1
movl $0x2, %ecx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4300
jmp 0xc9c9
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x4450
movb %al, 0x7(%rsp)
movl $0x1, %edx
leaq 0x70(%rsp), %rdi
leaq 0x7(%rsp), %rsi
callq 0x4340
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xca09
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
cmpq $0x1, %r13
jne 0xca2b
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0xca2b
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0xca47
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42e0
addq $0x2, %r15
cmpl 0x8(%r14), %r15d
jl 0xc92a
leaq 0x78(%rsp), %rsi
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x44e0
movq 0x10552(%rip), %rsi     # 0x1cfc0
leaq 0x70(%rsp), %rdi
callq 0x4170
leaq 0xe0(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcaa1
movq %rax, %rbx
jmp 0xcae7
movq %rax, %rbx
jmp 0xcb03
movq %rax, %rbx
jmp 0xcac5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xcac5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
cmpq $0x1, %r13
jne 0xcae7
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0xcae7
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0xcb03
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x104b6(%rip), %rsi     # 0x1cfc0
leaq 0x70(%rsp), %rdi
callq 0x4170
leaq 0xe0(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/global.cpp
// Function: bcd2hexa_no_f(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string bcd2hexa_no_f(const string &str)
{

    ostringstream value;


    string::const_iterator cii;
    for (cii=str.begin();cii!=str.end();cii++)
    {
        if (cii+1 == str.end() && (int)(uchar)(*cii & 0x0F) == 15) /* 15 = ascii of 'f' */
        {
            value << hex << setw(1) << (int)(uchar)((*cii >> 4) & 0x0F); /* Remove the last byte */
        } 
        else
        {
            value << hex << setw(2) << setfill('0') << (int)(uchar)*cii;
        }
    }


    return value.str();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x4420
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xcc11
movq (%r14), %rbp
addq %rbp, %rax
movq %rsp, %r15
leaq 0x1(%rbp), %r13
cmpq %rax, %r13
jne 0xcb9b
movb (%rbp), %al
notb %al
testb $0xf, %al
jne 0xcb9b
movq (%rsp), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rsp,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rsp,%rcx)
movq -0x18(%rax), %rax
movq $0x1, 0x10(%rsp,%rax)
movb (%rbp), %al
shrb $0x4, %al
jmp 0xcbf3
movq (%rsp), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rsp,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rsp,%rcx)
movq -0x18(%rax), %rcx
movq $0x2, 0x10(%rsp,%rcx)
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r12
cmpb $0x0, 0xe1(%r12)
jne 0xcbe7
movq %r12, %rdi
movl $0x20, %esi
callq 0x42a0
movb $0x1, 0xe1(%r12)
movb $0x30, 0xe0(%r12)
movb (%rbp), %al
movzbl %al, %esi
movq %r15, %rdi
callq 0x4560
movq (%r14), %rax
addq 0x8(%r14), %rax
movq %r13, %rbp
cmpq %rax, %r13
jne 0xcb5e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
movq 0x1039b(%rip), %rsi     # 0x1cfc0
movq %rsp, %rdi
callq 0x4170
leaq 0x70(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcc4e
movq %rax, %rbx
movq 0x10368(%rip), %rsi     # 0x1cfc0
movq %rsp, %rdi
callq 0x4170
leaq 0x70(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/global.cpp
// Function: treenode::_tree_dump(treenode*, int)
void treenode::_tree_dump(treenode *tree, int depth)
{
    vector<treenode *>::iterator    vii;
    (void)depth;

    if (tree!=NULL)
    {
        cout << "tagname:   " << tree->tagname << endl;
        cout << "cl:        " << tree->cl << endl;
        if (tree->value!=NULL)
        {
            cout << "value:     " <<  tree->value << endl;
        }
        cout << endl;

        if (tree->children!=NULL)
        {
            for (vii=tree->children->begin();vii!=tree->children->end();vii++)
            {
                _tree_dump(*vii, 0);
            }

        }

    }

}

// Assembly:
testq %rsi, %rsi
je 0xcde3
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10330(%rip), %r15     # 0x1cfc8
leaq 0x9d3c(%rip), %rsi      # 0x169db
movl $0xb, %edx
movq %r15, %rdi
callq 0x4340
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x4340
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41e0
leaq 0x9cfb(%rip), %rsi      # 0x169e7
movl $0xb, %edx
movq %r15, %rdi
callq 0x4340
movzwl 0x20(%rbx), %esi
andl $0x3, %esi
movq %r15, %rdi
callq 0x41d0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41e0
cmpq $0x0, 0x48(%rbx)
je 0xcd8a
movq 0x10288(%rip), %r12     # 0x1cfc8
leaq 0x9cac(%rip), %rsi      # 0x169f3
movl $0xb, %edx
movq %r12, %rdi
callq 0x4340
movq 0x48(%rbx), %rsi
movq %r12, %rdi
callq 0x4210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41e0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41e0
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0xcdd8
movq (%rax), %r15
cmpq 0x8(%rax), %r15
je 0xcdd8
movq (%r15), %rsi
movq %r14, %rdi
callq 0xcc7a
addq $0x8, %r15
movq 0x50(%rbx), %rax
jmp 0xcdbd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/global.cpp
// Function: bcd2int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string bcd2int(const string &str)
{
    ostringstream value_str;

    int value=0;
    string::const_iterator cii;

    for (cii=str.begin();cii!=str.end();cii++)
    {
        value+=(int)(uchar)*cii;
    }

    value_str << value;

    return value_str.str();

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x4420
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xce6f
movq (%r14), %rcx
xorl %edx, %edx
xorl %esi, %esi
movzbl (%rcx,%rdx), %edi
addl %edi, %esi
incq %rdx
cmpq %rdx, %rax
jne 0xce5f
jmp 0xce71
xorl %esi, %esi
movq %rsp, %rdi
callq 0x4560
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
movq 0x10133(%rip), %rsi     # 0x1cfc0
movq %rsp, %rdi
callq 0x4170
leaq 0x70(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10109(%rip), %rsi     # 0x1cfc0
movq %rsp, %rdi
callq 0x4170
leaq 0x70(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/global.cpp
// Function: int2bcd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string int2bcd(const string &str)
{

    ostringstream bcd;
    int intstr;


    intstr=atoi(str.c_str());


    while (intstr>0)
    {
        intstr>255 
            ? bcd << (uchar)255
            : bcd << (uchar)(intstr&0xFF);
        intstr-=255;
    }

    return bcd.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4420
movq (%r14), %rdi
callq 0x44d0
testl %eax, %eax
jle 0xcf47
movl %eax, %ebp
cmpl $0x100, %eax            # imm = 0x100
jb 0xcf30
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %r15
movb $-0x1, 0xf(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4340
addl $0xffffff01, %ebp       # imm = 0xFFFFFF01
cmpl $0xff, %ebp
ja 0xcf0d
leaq 0xf(%rsp), %rsi
movb %bpl, (%rsi)
leaq 0x10(%rsp), %rdi
movl $0x1, %edx
callq 0x4340
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
movq 0x10065(%rip), %rsi     # 0x1cfc0
leaq 0x10(%rsp), %rdi
callq 0x4170
leaq 0x80(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcf87
jmp 0xcf87
movq %rax, %rbx
movq 0x1002f(%rip), %rsi     # 0x1cfc0
leaq 0x10(%rsp), %rdi
callq 0x4170
leaq 0x80(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/global.cpp
// Function: free_treenode(treenode*)
void free_treenode(treenode *tree)
{
    vector<treenode *>::iterator    vii;

    if (tree!=NULL)
    {
        if (tree->value!=NULL)
        {
            delete tree->value;
        }

        if (tree->children!=NULL)
        {
            for (vii=tree->children->begin();vii!=tree->children->end();vii++)
            {
                free_treenode(*vii);
            }

            delete tree->children;
        }

        delete tree;
    }
}

// Assembly:
testq %rdi, %rdi
je 0xd7e8
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %r14
testq %r14, %r14
je 0xd773
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0xd766
movq (%rax), %rsi
incq %rsi
callq 0x42e0
movl $0x20, %esi
movq %r14, %rdi
callq 0x42e0
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0xd7bf
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0xd79e
movq (%r15), %rdi
callq 0xd735
addq $0x8, %r15
movq 0x50(%rbx), %r14
cmpq 0x8(%r14), %r15
jne 0xd785
movq (%r14), %r15
testq %r15, %r15
je 0xd7b2
movq 0x10(%r14), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x42e0
movl $0x18, %esi
movq %r14, %rdi
callq 0x42e0
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0xd7d6
movq (%rax), %rsi
incq %rsi
callq 0x42e0
movl $0x58, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x42e0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/Buffin.cpp
// Function: Buffin::set_pos(long const&)
void  Buffin::set_pos(const long &pos)
{
    if (pos > this->get_end())
    {
        cerr << "Trying to read beyond the end of file. Pos: " << pos << " End: " << this->get_end() << endl;
        err_trace(__FILE__, __LINE__);
    }

    _pos=pos;
    if (!_mode)
    {
        _file_in.seekg(pos);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq 0x228(%rdi), %rax
jle 0xdda1
movq 0xf310(%rip), %r15      # 0x1cff0
leaq 0x8df7(%rip), %rsi      # 0x16ade
movl $0x2c, %edx
movq %r15, %rdi
callq 0x4340
movq (%r14), %rsi
movq %r15, %rdi
callq 0x4290
movq %rax, %r15
leaq 0x8e02(%rip), %rsi      # 0x16b0b
movl $0x6, %edx
movq %rax, %rdi
callq 0x4340
movq 0x228(%rbx), %rsi
movq %r15, %rdi
callq 0x4290
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41e0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8d59(%rip), %rsi      # 0x16ab9
leaq 0x8d5c(%rip), %rdx      # 0x16ac3
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6c96
leaq 0x4(%rsp), %rsi
movl $0x92, (%rsi)
movq %r15, %rdi
callq 0xcde4
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xdd9e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq (%r14), %rax
movq %rax, 0x220(%rbx)
cmpl $0x0, 0x230(%rbx)
jne 0xddc2
addq $0x18, %rbx
movq (%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x43d0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xdde8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/Buffin.cpp
// Function: Buffin::read(long)
void  Buffin::read(const long len)
{

    /* 1. Allocation of memory */

    if (_curbuf != NULL)
        delete [] _curbuf;
    
    _curbuf=new uchar[len];


    /* 2. Reading into current buffer */

    if(_mode)
    {
        ;
    } 
    else 
    {
        if (this->get_pos() + len <= this->get_end())
            memcpy(_curbuf, _buffin+this->get_pos(), len);
        else
        {
            cerr << "Trying to read " << len << " bytes beyond end of file from position "<<this->get_pos();
            cerr << ". File might be corrupted." << endl;
            err_trace( __FILE__, __LINE__) ;
        }

    }

    _curbuf_len=len;


    /* 3. Update position */

    this->set_pos(this->get_pos()+len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xde17
callq 0x43e0
movq %r14, %rdi
callq 0x4030
movq %rax, 0x8(%rbx)
cmpl $0x0, 0x230(%rbx)
jne 0xdf2e
movq 0x220(%rbx), %rsi
leaq (%rsi,%r14), %rcx
cmpq 0x228(%rbx), %rcx
jle 0xdf20
movq 0xf1a1(%rip), %r15      # 0x1cff0
leaq 0x8cbc(%rip), %rsi      # 0x16b12
movl $0xf, %edx
movq %r15, %rdi
callq 0x4340
movq %r15, %rdi
movq %r14, %rsi
callq 0x4290
movq %rax, %r12
leaq 0x8caa(%rip), %rsi      # 0x16b22
movl $0x28, %edx
movq %rax, %rdi
callq 0x4340
movq 0x220(%rbx), %rsi
movq %r12, %rdi
callq 0x4290
leaq 0x8cb0(%rip), %rsi      # 0x16b4b
movl $0x1a, %edx
movq %r15, %rdi
callq 0x4340
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41e0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8bd9(%rip), %rsi      # 0x16ab9
leaq 0x8bdc(%rip), %rdx      # 0x16ac3
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6c96
leaq 0x4(%rsp), %rsi
movl $0xba, (%rsi)
movq %r15, %rdi
callq 0xcde4
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xdf2e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0xdf2e
addq (%rbx), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x4240
movq %r14, 0x10(%rbx)
addq 0x220(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xdcb8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xdf6f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/Buffin.cpp
// Function: Buffin::~Buffin()
Buffin::~Buffin()
{
    if (_mode)
        _file_in.close();
    if (_buffin != NULL)
        delete [] _buffin ;
    if (_curbuf != NULL)
        delete [] _curbuf;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x230(%rdi)
je 0xe070
leaq 0x18(%rbx), %rdi
callq 0x40a0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xe07d
callq 0x43e0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xe08b
callq 0x43e0
addq $0x18, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x40b0
movq %rax, %rdi
callq 0x6bf4
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/Buffout.cpp
// Function: Buffout::Buffout(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Buffout::Buffout(const string filename) :
    _curbuf(NULL)
{

    /* 1. Open file */

    _file_out.open(filename.c_str(), ios::binary | ios::out);

    if (!_file_out.good())
    {
        cerr << "Unable to open file: " << filename ;
        err_trace(__FILE__, __LINE__);
    }

    _strm_out = new ostream(_file_out.rdbuf());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq $0x0, 0x8(%rdi)
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x4550
movq (%r15), %rsi
movq %rbx, %rdi
movl $0x14, %edx
callq 0x4070
movq (%rbx), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rbx,%rax)
je 0xe1d3
movq 0xee8e(%rip), %rdi      # 0x1cff0
leaq 0x893a(%rip), %rsi      # 0x16aa3
movl $0x15, %edx
callq 0x4340
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0xee6f(%rip), %rdi      # 0x1cff0
callq 0x4340
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x89d0(%rip), %rsi      # 0x16b66
leaq 0x89d4(%rip), %rdx      # 0x16b71
leaq 0x10(%rsp), %rdi
callq 0x6c96
leaq 0xc(%rsp), %rsi
movl $0x3f, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0xcde4
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0xe1d3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movl $0x110, %edi            # imm = 0x110
callq 0x42d0
movq %rax, %r15
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x4120
movq %r15, 0x218(%r14)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0xe22b
movq 0x20(%rsp), %rsi
incq %rsi
jmp 0xe221
jmp 0xe228
movq %rax, %r14
movl $0x110, %esi            # imm = 0x110
movq %r15, %rdi
callq 0x42e0
jmp 0xe22b
movq %rax, %r14
movq %rbx, %rdi
callq 0x4490
movq %r14, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/Buffout.cpp
// Function: Buffout::~Buffout()
Buffout::~Buffout() 
{
    _file_out.close();
    if (_strm_out != NULL)
        delete _strm_out;

    if (_curbuf != NULL)
        delete [] _curbuf;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x4460
movq 0x218(%rbx), %rdi
testq %rdi, %rdi
je 0xe27d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xe28b
callq 0x43e0
movq 0xed1e(%rip), %rax      # 0x1cfb0
movq (%rax), %rcx
movq 0x18(%rax), %rax
movq %rcx, 0x18(%rbx)
movq -0x18(%rcx), %rcx
movq %rax, 0x18(%rbx,%rcx)
leaq 0x20(%rbx), %rdi
callq 0x4250
addq $0x110, %rbx            # imm = 0x110
movq %rbx, %rdi
popq %rbx
jmp 0x4100
movq %rax, %rdi
callq 0x6bf4
nop
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/Asn.cpp
// Function: Asn::_decode_spec()
void Asn::_decode_spec()
{

    /* 1. Parse Specification */

    if (_specfile==NULL)
    {
        cerr << "Error. Specification File must be specified with method \"specfile\"";
        err_trace(__FILE__, __LINE__);
    }

    extern  int run_asn1parser(FILE *_specfile, FILE *_specsuplfile, map<string,tagtype_s *> *spec_tree);

    if (run_asn1parser(_specfile, _specsuplfile, &_spec_tree))
    {
        cerr << "Error decoding ASN input file\n";
        err_trace(__FILE__, __LINE__);
    }


    /* 2. Compile */

    _compile_spec(&_spec_tree);

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
jne 0xe410
movq 0xec42(%rip), %rdi      # 0x1cff0
leaq 0x87bd(%rip), %rsi      # 0x16b72
movl $0x42, %edx
callq 0x4340
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x87e6(%rip), %rsi      # 0x16bb5
leaq 0x87e6(%rip), %rdx      # 0x16bbc
leaq 0x8(%rsp), %rdi
callq 0x6c96
leaq 0x4(%rsp), %rsi
movl $0x9f, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0xcde4
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xe40c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
addq $0x60, %rbx
movq %rbx, %rdx
callq 0x8ee8
testl %eax, %eax
je 0xe489
movq 0xebc5(%rip), %rdi      # 0x1cff0
leaq 0x878b(%rip), %rsi      # 0x16bbd
movl $0x1e, %edx
callq 0x4340
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x8769(%rip), %rsi      # 0x16bb5
leaq 0x8769(%rip), %rdx      # 0x16bbc
leaq 0x8(%rsp), %rdi
callq 0x6c96
leaq 0x4(%rsp), %rsi
movl $0xa7, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0xcde4
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xe489
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rsi
callq 0xe4c4
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0xe49d
jmp 0xe4b9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xe4bc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0xe4bc
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/Asn.cpp
// Function: Asn::encode()
void Asn::encode()
{

    /* 1. Decode Specification */

    _decode_spec();


    /* 2. Match our Tree with the specification */

    if (!_spec_rootnode.size())
    {
        cerr << "Error. The root node should be specified with the method \"specroot\"";
        err_trace(__FILE__, __LINE__);
    }

    _compile_tree(_spec_tree[_spec_rootnode],_tree);

    if (!_tree->tag_d)
    {
        _tree->tag_d=_spec_tree[_spec_rootnode]->tagid;
    }

    /* 3. Encode */

    TreeParser *tparser=new TreeParser;
    tparser->handler(_asnitem);
    tparser->buffout(_bfout);
    tparser->tree(_tree);
    tparser->process();
    delete tparser; 
    tparser = NULL;

    _bfout->flush();

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0xe394
cmpq $0x0, 0x48(%rbx)
jne 0x11dbf
movq 0xb28f(%rip), %rdi      # 0x1cff0
leaq 0x4ea6(%rip), %rsi      # 0x16c0e
movl $0x43, %edx
callq 0x4340
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x4e33(%rip), %rsi      # 0x16bb5
leaq 0x4e33(%rip), %rdx      # 0x16bbc
leaq 0x10(%rsp), %rdi
callq 0x6c96
leaq 0xc(%rsp), %rsi
movl $0x596, (%rsi)          # imm = 0x596
leaq 0x10(%rsp), %rdi
callq 0xcde4
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x11dbf
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
leaq 0x40(%rbx), %r14
leaq 0x60(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xa082
movq (%rax), %rsi
movq 0x18(%rbx), %rdx
movq %rbx, %rdi
callq 0x10bb8
movq 0x18(%rbx), %rax
cmpl $0x0, 0x24(%rax)
jne 0x11e03
movq %r15, %rdi
movq %r14, %rsi
callq 0xa082
movq (%rax), %rax
movl 0x40(%rax), %eax
movq 0x18(%rbx), %rcx
movl %eax, 0x24(%rcx)
movl $0x18, %edi
callq 0x42d0
movq %rax, %r14
movq %rax, %rdi
callq 0x13848
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x13858
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1388e
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x13876
movq %r14, %rdi
callq 0x138ae
movq %r14, %rdi
callq 0x139d4
movl $0x18, %esi
movq %r14, %rdi
callq 0x42e0
movq 0x8(%rbx), %rdi
callq 0xe252
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x11e98
movq 0x20(%rsp), %rsi
incq %rsi
jmp 0x11e93
movq %rax, %rbx
jmp 0x11e98
movq %rax, %rbx
movl $0x18, %esi
movq %r14, %rdi
callq 0x42e0
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/Asn.cpp
// Function: Asn::specfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Asn::specfile(const string &filename)
{

    if (!(_specfile=fopen(filename.c_str(), "rb")))
    {
        cerr << "Error trying to open or not found specification file: " << filename;
        if (getenv(TAP3XML_SPEC_VAR) == NULL)
            cerr << "\nYou can set the variable " << TAP3XML_SPEC_VAR << " to point to the directory of the specifications";
        err_trace(__FILE__, __LINE__);
    }

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
leaq 0x338f(%rip), %rsi      # 0x15246
callq 0x4360
movq %rax, 0x30(%r14)
testq %rax, %rax
jne 0x11f95
movq 0xb120(%rip), %r14      # 0x1cff0
leaq 0x508c(%rip), %rsi      # 0x16f63
movl $0x36, %edx
movq %r14, %rdi
callq 0x4340
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x4340
leaq 0x3155(%rip), %rdi      # 0x1504f
callq 0x4390
testq %rax, %rax
jne 0x11f47
movq 0xb0e5(%rip), %rbx      # 0x1cff0
leaq 0x5088(%rip), %rsi      # 0x16f9a
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x4340
leaq 0x3129(%rip), %rsi      # 0x1504f
movl $0xc, %edx
movq %rbx, %rdi
callq 0x4340
leaq 0x507b(%rip), %rsi      # 0x16fb5
movl $0x30, %edx
movq %rbx, %rdi
callq 0x4340
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x4c5e(%rip), %rsi      # 0x16bb5
leaq 0x4c5e(%rip), %rdx      # 0x16bbc
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6c96
leaq 0x4(%rsp), %rsi
movl $0x5ca, (%rsi)          # imm = 0x5CA
movq %rbx, %rdi
callq 0xcde4
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x11f95
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x11fb7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/Asn.cpp
// Function: Asn::_free_spec_tree(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, tagtype_s*, 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, tagtype_s*>>>&)
void Asn::_free_spec_tree(map<string,tagtype_s *> &spec_tree)
{
    map<string,tagtype_s *>::iterator   mii;
    vector<tagelem_s *>::iterator       vii;
    vector<tagelem_s *>*                children;


    for(mii=spec_tree.begin();mii!=spec_tree.end();mii++)
    {
        if (mii->second!=NULL)
        {
            if (mii->second->children!=NULL && mii->second->modified==false)
            {
                children=mii->second->children;

                for(vii=children->begin();vii!=children->end();vii++)
                {
                    if (*vii!=NULL)
                    {
                        delete *vii;
                        *vii=NULL;
                    }
                }

                delete mii->second->children;
                mii->second->children=NULL;
            }

            delete mii->second;
            mii->second=NULL;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rsi), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x125d2
movq 0x40(%r14), %r12
testq %r12, %r12
je 0x125be
movq 0x50(%r12), %r15
testq %r15, %r15
je 0x12576
cmpb $0x0, 0x49(%r12)
jne 0x12576
movq (%r15), %r12
movq 0x8(%r15), %rax
cmpq %rax, %r12
je 0x12543
movq (%r12), %r13
testq %r13, %r13
je 0x1252a
movq 0x20(%r13), %rdi
leaq 0x30(%r13), %rax
cmpq %rax, %rdi
je 0x124f9
movq (%rax), %rsi
incq %rsi
callq 0x42e0
movq (%r13), %rdi
leaq 0x10(%r13), %rax
cmpq %rax, %rdi
je 0x12511
movq (%rax), %rsi
incq %rsi
callq 0x42e0
movl $0x50, %esi
movq %r13, %rdi
callq 0x42e0
movq $0x0, (%r12)
movq 0x8(%r15), %rax
addq $0x8, %r12
cmpq %rax, %r12
jne 0x124d8
movq 0x40(%r14), %rax
movq 0x50(%rax), %r15
testq %r15, %r15
je 0x12559
movq (%r15), %r12
testq %r12, %r12
je 0x1255c
movq 0x10(%r15), %rsi
subq %r12, %rsi
movq %r12, %rdi
callq 0x42e0
jmp 0x1255c
xorl %r15d, %r15d
movl $0x18, %esi
movq %r15, %rdi
callq 0x42e0
movq 0x40(%r14), %r12
movq $0x0, 0x50(%r12)
movq 0x20(%r12), %rdi
leaq 0x30(%r12), %rax
cmpq %rax, %rdi
je 0x12590
movq (%rax), %rsi
incq %rsi
callq 0x42e0
movq (%r12), %rdi
leaq 0x10(%r12), %rax
cmpq %rax, %rdi
je 0x125a9
movq (%rax), %rsi
incq %rsi
callq 0x42e0
movl $0x58, %esi
movq %r12, %rdi
callq 0x42e0
movq $0x0, 0x40(%r14)
movq %r14, %rdi
callq 0x41f0
movq %rax, %r14
cmpq %rbx, %rax
jne 0x124a5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/Asn.cpp
// Function: Asn::_dump_asn_tree(treenode*, int)
void Asn::_dump_asn_tree(
        treenode *tree,
        int depth
        )
{

    vector<treenode *>::iterator    vii;

    cout << string(depth*4, ' ') << tree->tagname << " (" << tree->tag_d << ")";
    if (tree->value)
        cout << " \"" << *(tree->value) << "\"";
    cout << "\n";

    if (tree->children!=NULL)
    {

        for (vii=tree->children->begin();vii!=tree->children->end();vii++)
        {
            _dump_asn_tree(*vii, depth +1);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leal (,%rbx,4), %eax
movslq %eax, %rsi
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsp, %r12
movq %r12, %rdi
movl $0x20, %edx
callq 0x4350
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq 0xa9a4(%rip), %rdi      # 0x1cfc8
callq 0x4340
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x4340
movq %rax, %r12
leaq 0x3b54(%rip), %rsi      # 0x16196
movl $0x2, %edx
movq %rax, %rdi
callq 0x4340
movl 0x24(%r14), %esi
movq %r12, %rdi
callq 0x4560
leaq 0x36bc(%rip), %rsi      # 0x15d1e
movl $0x1, %edx
movq %rax, %rdi
callq 0x4340
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x12685
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
cmpq $0x0, 0x48(%r14)
je 0x126ce
movq 0xa935(%rip), %r12      # 0x1cfc8
leaq 0x477a(%rip), %rsi      # 0x16e14
movl $0x2, %edx
movq %r12, %rdi
callq 0x4340
movq 0x48(%r14), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r12, %rdi
callq 0x4340
leaq 0x4754(%rip), %rsi      # 0x16e15
movl $0x1, %edx
movq %rax, %rdi
callq 0x4340
movq 0xa8f3(%rip), %rdi      # 0x1cfc8
leaq 0x4333(%rip), %rsi      # 0x16a0f
movl $0x1, %edx
callq 0x4340
movq 0x50(%r14), %rax
testq %rax, %rax
je 0x12716
movq (%rax), %r12
cmpq 0x8(%rax), %r12
je 0x12716
incl %ebx
movq (%r12), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x125dc
addq $0x8, %r12
movq 0x50(%r14), %rax
cmpq 0x8(%rax), %r12
jne 0x126fa
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1273d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/Asn.cpp
// Function: Asn::~Asn()
Asn::~Asn() 
{
    _free_spec_tree(_spec_tree);

    if (_asnitem)
    {
        delete _asnitem; 
        _asnitem = NULL;
    }

    if (_specfile!=NULL)
    {
        fclose(_specfile);
    }

    if (_specsuplfile!=NULL)
    {
        fclose(_specsuplfile);
    }

    if (_bfout!=NULL)
    {
        delete _bfout; 
        _bfout = NULL;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
movq %r14, %rsi
callq 0x12488
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x12771
movq (%rdi), %rax
callq *0x28(%rax)
movq $0x0, 0x10(%rbx)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x1277f
callq 0x42c0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x1278d
callq 0x42c0
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x127b3
movq %r15, %rdi
callq 0xe25e
movl $0x220, %esi            # imm = 0x220
movq %r15, %rdi
callq 0x42e0
movq $0x0, 0x8(%rbx)
movq %r14, %rdi
callq 0x128c0
movq 0x40(%rbx), %rdi
addq $0x50, %rbx
cmpq %rbx, %rdi
je 0x127d8
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x42e0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/AsnItem.cpp
// Function: AsnItem::enc_close[abi:cxx11](int)
string AsnItem::enc_close(int depth)
{

    /* ASN.1 does not use any close statement for tags.    */
    /* You know when a tag finishes, from its size.        */
    /* Anyway, this could be useful to create files with    */
    /* indefinite length. \0\0 Should come here.        */

    (void) depth;
    return string("");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x32b8(%rip), %rdx      # 0x16a10
movq %rdx, %rsi
callq 0x6c96
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/TreeParser.cpp
// Function: TreeParser::_process(treenode*, int)
void TreeParser::_process(treenode *tree, int depth)
{

    vector<treenode *>::iterator   vii;

    _treeitem->tree(tree);
    _bfout->write(_treeitem->encode(depth));

    if (tree->children != NULL)
    {

        for(vii=tree->children->begin();vii!=tree->children->end();vii++)
        {
            this->_process((*vii), depth+1);
        }

    }

    _treeitem->tree(tree);
    _bfout->write(_treeitem->enc_close(depth));

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r14), %r12
movq 0x10(%r14), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movl %ebx, %edx
callq *0x10(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0xe23c
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x13918
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x50(%r15), %rax
testq %rax, %rax
je 0x13949
movq (%rax), %r13
cmpq 0x8(%rax), %r13
je 0x13949
leal 0x1(%rbx), %ebp
movq (%r13), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x138ba
addq $0x8, %r13
movq 0x50(%r15), %rax
cmpq 0x8(%rax), %r13
jne 0x1392d
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x8(%rax)
movq (%r14), %r15
movq 0x10(%r14), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebx, %edx
callq *0x18(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0xe23c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1398f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
jne 0x139be
jmp 0x139cb
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x139cb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/Xml.cpp
// Function: Xml::Xml()
Xml::Xml() 
{
    _xmlitem=new XmlItem;
    _tree=NULL;
    _bfin=NULL;
    _bfout=NULL;
    _ofile=NULL;
    _ifile=NULL;
    _header=NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x48, %edi
callq 0x42d0
movq %rax, %r14
movq %rax, %rdi
callq 0x13e10
movq %r14, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x48, %esi
movq %r14, %rdi
callq 0x42e0
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/Xml.cpp
// Function: Xml::decode()
void Xml::decode()
{

    extern int run_xmlparser(FILE *ifile, treenode *tree);


    /* 1. Parse xml structure */

    if (_ifile == NULL )
    {
        cerr << "The XML input file should be specified with the \"ifile\" method";
        err_trace(__FILE__, __LINE__);
    }

    if (run_xmlparser(_ifile, _tree))
    {
        cerr << "Error decoding XML input file\n";
        err_trace(__FILE__, __LINE__);
    }

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0x13aa2
movq 0x95b0(%rip), %rdi      # 0x1cff0
leaq 0x36e3(%rip), %rsi      # 0x1712a
movl $0x3e, %edx
callq 0x4340
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3708(%rip), %rsi      # 0x17169
leaq 0x3708(%rip), %rdx      # 0x17170
leaq 0x8(%rsp), %rdi
callq 0x6c96
leaq 0x4(%rsp), %rsi
movl $0x42, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0xcde4
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x13a9e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x20(%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0xb8dd
testl %eax, %eax
je 0x13b14
movq 0x953a(%rip), %rdi      # 0x1cff0
leaq 0x36b4(%rip), %rsi      # 0x17171
movl $0x1e, %edx
callq 0x4340
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3692(%rip), %rsi      # 0x17169
leaq 0x3692(%rip), %rdx      # 0x17170
leaq 0x8(%rsp), %rdi
callq 0x6c96
leaq 0x4(%rsp), %rsi
movl $0x48, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0xcde4
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x13b14
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x13b20
jmp 0x13b3c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x13b3f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x13b3f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/Xml.cpp
// Function: Xml::encode()
void Xml::encode()
{

    _bfout->write(get_header());

    TreeParser *tparser=new TreeParser;
    tparser->handler(_xmlitem);
    tparser->buffout(_bfout);
    tparser->tree(_tree);
    tparser->process();
    delete tparser;

    _bfout->flush();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x13c28
movq %r14, %rdi
movq %r15, %rsi
callq 0xe23c
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13b8c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movl $0x18, %edi
callq 0x42d0
movq %rax, %r14
movq %rax, %rdi
callq 0x13848
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x13858
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1388e
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x13876
movq %r14, %rdi
callq 0x138ae
movq %r14, %rdi
callq 0x139d4
movl $0x18, %esi
movq %r14, %rdi
callq 0x42e0
movq 0x8(%rbx), %rdi
callq 0xe252
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r14, %rdi
jmp 0x13c1b
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13c20
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/Xml.cpp
// Function: Xml::get_header[abi:cxx11]()
string Xml::get_header()
{
    if (_header != NULL)
    {
        return *_header;
    }
    else
    {
        return "";
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rsi), %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
testq %rax, %rax
je 0x13c50
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x6c00
jmp 0x13c62
leaq 0x2db9(%rip), %rdx      # 0x16a10
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6c96
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tap3edit[P]tap3xml/XmlItem.cpp
// Function: XmlItem::enc_close[abi:cxx11](int)
string XmlItem::enc_close(int depth)
{
    ostringstream item;


    if (_tree==NULL) {
        cerr << "treenode structure was not set with tree() method";
        err_trace(__FILE__, __LINE__);
    }


    /* 1. Preparing XML closing Item */

    if ( _tree->pc )
    {
        item << string(depth*4, ' ') << "</" << _tree->tagname << ">\n";
    }


    /* 2. Return */

    return item.str();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4420
movq 0x40(%r14), %rax
testq %rax, %rax
jne 0x141fa
movq 0x8e53(%rip), %rdi      # 0x1cff0
leaq 0x2a38(%rip), %rsi      # 0x16bdc
movl $0x31, %edx
callq 0x4340
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2fee(%rip), %rsi      # 0x171ac
leaq 0x2ff2(%rip), %rdx      # 0x171b7
movq %rsp, %rdi
callq 0x6c96
leaq 0x24(%rsp), %rsi
movl $0x66, (%rsi)
movq %rsp, %rdi
callq 0xcde4
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x141f6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x40(%r14), %rax
testb $0x4, 0x20(%rax)
je 0x14288
shll $0x2, %ebp
movslq %ebp, %rsi
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rsp, %rdi
movl $0x20, %edx
callq 0x4350
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x4340
movq %rax, %r15
leaq 0x2f7a(%rip), %rsi      # 0x171b8
movl $0x2, %edx
movq %rax, %rdi
callq 0x4340
movq 0x40(%r14), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x4340
leaq 0xf13(%rip), %rsi       # 0x15178
movl $0x2, %edx
movq %rax, %rdi
callq 0x4340
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x14288
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
movq 0x8d24(%rip), %rsi      # 0x1cfc0
leaq 0x28(%rsp), %rdi
callq 0x4170
leaq 0x98(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x142e9
jmp 0x142f6
jmp 0x142d8
jmp 0x142d8
movq %rax, %rbx
jmp 0x142f6
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x142f6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x8cc3(%rip), %rsi      # 0x1cfc0
leaq 0x28(%rsp), %rdi
callq 0x4170
leaq 0x98(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O3/eniac[P]Mantis/./include/ast_nodes.h
// Function: InputNode::InputNode(AstNode*, AstNode*)
InputNode(AstNode* next, AstNode* expression) {
        nodeType_ = typeid(*this).name();
        next_ = dynamic_cast<InputNode*>(next);
        expression_ = expression;
        expression_->parent_ = this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb $0x1, 0x8(%rdi)
addq $0x10, %rdi
leaq 0x20(%rbx), %r12
movq %r12, 0x10(%rbx)
movl $0x65736162, 0x20(%rbx) # imm = 0x65736162
movq $0x4, 0x18(%rbx)
xorl %eax, %eax
movb %al, 0x24(%rbx)
movq $0x0, 0x30(%rbx)
movb %al, 0x38(%rbx)
leaq 0x5a5be(%rip), %rax     # 0x8c9e0
movq %rax, (%rbx)
leaq 0x42888(%rip), %rcx     # 0x74cb4
movl $0x4, %edx
movl $0xa, %r8d
xorl %esi, %esi
callq 0x2e640
testq %r15, %r15
je 0x3245d
leaq 0x5a266(%rip), %rsi     # 0x8c6b0
leaq 0x5a597(%rip), %rdx     # 0x8c9e8
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x2e430
jmp 0x3245f
xorl %eax, %eax
movq %rax, 0x40(%rbx)
movq %r14, 0x48(%rbx)
movq %rbx, 0x30(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x5a592(%rip), %rax     # 0x8ca10
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
cmpq %r12, %rdi
je 0x3248f
callq 0x2e360
movq %r14, %rdi
callq 0x2e730
nop
// File: /workspace/github_cpp_makefile_star2_O3/eniac[P]Mantis/./include/ast_nodes.h
// Function: InputNode::toString[abi:cxx11]()
string toString() {
        ostringstream oss;
        if (next_) {
            oss << next_->toString() << "\n";
        }
        oss << expression_->toString();
        return oss.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x2e550
movq 0x40(%r14), %rsi
testq %rsi, %rsi
je 0x32bac
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *(%rax)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x1a8(%rbp), %rdi
callq 0x2e440
leaq 0x43237(%rip), %rsi     # 0x75dc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x2e440
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32bac
callq 0x2e360
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *(%rax)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x1a8(%rbp), %rdi
callq 0x2e440
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32bdf
callq 0x2e360
leaq -0x1a0(%rbp), %rsi
movq %rbx, %rdi
callq 0x2e660
movq 0x5b3b3(%rip), %rsi     # 0x8dfa8
leaq -0x1a8(%rbp), %rdi
callq 0x2e230
leaq -0x138(%rbp), %rdi
callq 0x2e150
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x32c22
jmp 0x32c22
jmp 0x32c27
movq %rax, %rbx
jmp 0x32c3c
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32c3c
callq 0x2e360
movq 0x5b365(%rip), %rsi     # 0x8dfa8
leaq -0x1a8(%rbp), %rdi
callq 0x2e230
leaq -0x138(%rbp), %rdi
callq 0x2e150
movq %rbx, %rdi
callq 0x2e730
nop
// File: /workspace/github_cpp_makefile_star2_O3/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: BodyWordNode::deepCopy()
BodyWordNode* BodyWordNode::deepCopy() {
    AstNode* newContents = contents_;
    if (wordType_ == WordType::VARREF) {
        newContents = dynamic_cast<MblRefNode*>(contents_)->deepCopy();
    }

    auto newNode = new BodyWordNode(wordType_, newContents);
    return newNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x40(%rdi), %rbx
movl 0x3c(%rdi), %r15d
testl %r15d, %r15d
jne 0x34fff
movq %rdi, %r14
leaq 0x576d1(%rip), %rsi     # 0x8c6b0
leaq 0x58512(%rip), %rdx     # 0x8d4f8
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x2e430
movq %rax, %rdi
callq 0x3dee6
movq %rax, %rbx
movl 0x3c(%r14), %r15d
movl $0x50, %edi
callq 0x2e3a0
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x34f1c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x2e360
movq %rbx, %rdi
callq 0x2e730
nop
// File: /workspace/github_cpp_makefile_star2_O3/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: operator*(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
static string operator*(std::string str, int count)
{
    string ret;
    for(auto i = 0; i<count; i++) {
        ret = ret + str;
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %edx, %edx
jle 0x35409
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x40(%rbp), %r13
leaq -0x50(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x397db
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2e4c0
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x35404
callq 0x2e360
decl %r14d
jne 0x353dd
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x35429
callq 0x2e360
movq %r14, %rdi
callq 0x2e730
nop
// File: /workspace/github_cpp_makefile_star2_O3/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: BodyNode::BodyNode(AstNode*, AstNode*, AstNode*)
BodyNode::BodyNode(AstNode* bodyOuter, AstNode* bodyInner, AstNode* str) {

    nodeType_ = typeid(*this).name();
    bodyOuter_ = dynamic_cast<BodyNode*>(bodyOuter);
    if (bodyOuter_) bodyOuter_->parent_ = this;
    bodyInner_ = dynamic_cast<BodyNode*>(bodyInner);
    if (bodyInner_) {
        bodyInner_->parent_ = this;
    }
    str_ = dynamic_cast<BodyWordNode*>(str);
    if (str_) {
        str_->parent_ = this;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movb $0x1, 0x8(%rdi)
addq $0x10, %rdi
leaq 0x20(%rbx), %r13
movq %r13, 0x10(%rbx)
movl $0x65736162, 0x20(%rbx) # imm = 0x65736162
movq $0x4, 0x18(%rbx)
xorl %eax, %eax
movb %al, 0x24(%rbx)
movq $0x0, 0x30(%rbx)
movb %al, 0x38(%rbx)
leaq 0x576de(%rip), %rax     # 0x8cb60
movq %rax, (%rbx)
movl $0x1, 0x58(%rbx)
leaq 0x409d7(%rip), %rcx     # 0x75e6a
movl $0x4, %edx
movl $0x9, %r8d
xorl %esi, %esi
callq 0x2e640
testq %r12, %r12
je 0x354d1
leaq 0x571ff(%rip), %rsi     # 0x8c6b0
leaq 0x576e0(%rip), %rdx     # 0x8cb98
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x2e430
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x354d9
movq %rbx, 0x30(%rax)
jmp 0x354d9
movq $0x0, 0x40(%rbx)
testq %r15, %r15
je 0x35505
leaq 0x571cb(%rip), %rsi     # 0x8c6b0
leaq 0x576ac(%rip), %rdx     # 0x8cb98
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x2e430
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x3550d
movq %rbx, 0x30(%rax)
jmp 0x3550d
movq $0x0, 0x48(%rbx)
testq %r14, %r14
je 0x35539
leaq 0x57197(%rip), %rsi     # 0x8c6b0
leaq 0x57648(%rip), %rdx     # 0x8cb68
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x2e430
movq %rax, 0x50(%rbx)
testq %rax, %rax
je 0x35541
movq %rbx, 0x30(%rax)
jmp 0x35541
movq $0x0, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x574b6(%rip), %rax     # 0x8ca10
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
cmpq %r13, %rdi
je 0x3556b
callq 0x2e360
movq %r14, %rdi
callq 0x2e730
nop