LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x30(%rdi)
jne 0xeaa6
movq 0xe5a8(%rip), %rdi      # 0x1cff0
leaq 0x8123(%rip), %rsi      # 0x16b72
movl $0x42, %edx
callq 0x4340
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x814c(%rip), %rsi      # 0x16bb5
leaq 0x814c(%rip), %rdx      # 0x16bbc
leaq 0x8(%rsp), %rdi
callq 0x6e3c
leaq 0x4(%rsp), %rsi
movl $0x9f, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0xd138
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xeaa6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
addq $0x60, %rbx
movq %rbx, %rdx
callq 0x9157
testl %eax, %eax
je 0xeb23
movq 0xe52b(%rip), %rdi      # 0x1cff0
leaq 0x80f1(%rip), %rsi      # 0x16bbd
movl $0x1e, %edx
callq 0x4340
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x80cf(%rip), %rsi      # 0x16bb5
leaq 0x80cf(%rip), %rdx      # 0x16bbc
leaq 0x8(%rsp), %rdi
callq 0x6e3c
leaq 0x4(%rsp), %rsi
movl $0xa7, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0xd138
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xeb23
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rsi
callq 0xeb5e
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0xeb37
jmp 0xeb53
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xeb56
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0xeb56
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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 0xea30
cmpq $0x0, 0x48(%rbx)
jne 0x124bd
movq 0xab91(%rip), %rdi      # 0x1cff0
leaq 0x47a8(%rip), %rsi      # 0x16c0e
movl $0x43, %edx
callq 0x4340
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x4735(%rip), %rsi      # 0x16bb5
leaq 0x4735(%rip), %rdx      # 0x16bbc
leaq 0x10(%rsp), %rdi
callq 0x6e3c
leaq 0xc(%rsp), %rsi
movl $0x596, (%rsi)          # imm = 0x596
leaq 0x10(%rsp), %rdi
callq 0xd138
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x124bd
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
leaq 0x40(%rbx), %r14
leaq 0x60(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xa304
movq (%rax), %rsi
movq 0x18(%rbx), %rdx
movq %rbx, %rdi
callq 0x1128e
movq 0x18(%rbx), %rax
cmpl $0x0, 0x24(%rax)
jne 0x12501
movq %r15, %rdi
movq %r14, %rsi
callq 0xa304
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 0x13fc0
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x13fd0
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x14006
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x13fee
movq %r14, %rdi
callq 0x14026
movq %r14, %rdi
callq 0x14150
movl $0x18, %esi
movq %r14, %rdi
callq 0x42e0
movq 0x8(%rbx), %rdi
callq 0xe8ee
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x12596
movq 0x20(%rsp), %rsi
incq %rsi
jmp 0x12591
movq %rax, %rbx
jmp 0x12596
movq %rax, %rbx
movl $0x18, %esi
movq %r14, %rdi
callq 0x42e0
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c91(%rip), %rsi      # 0x15246
callq 0x4360
movq %rax, 0x30(%r14)
testq %rax, %rax
jne 0x12693
movq 0xaa22(%rip), %r14      # 0x1cff0
leaq 0x498e(%rip), %rsi      # 0x16f63
movl $0x36, %edx
movq %r14, %rdi
callq 0x4340
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x4340
leaq 0x2a57(%rip), %rdi      # 0x1504f
callq 0x4390
testq %rax, %rax
jne 0x12645
movq 0xa9e7(%rip), %rbx      # 0x1cff0
leaq 0x498a(%rip), %rsi      # 0x16f9a
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x4340
leaq 0x2a2b(%rip), %rsi      # 0x1504f
movl $0xc, %edx
movq %rbx, %rdi
callq 0x4340
leaq 0x497d(%rip), %rsi      # 0x16fb5
movl $0x30, %edx
movq %rbx, %rdi
callq 0x4340
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x4560(%rip), %rsi      # 0x16bb5
leaq 0x4560(%rip), %rdx      # 0x16bbc
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6e3c
leaq 0x4(%rsp), %rsi
movl $0x5ca, (%rsi)          # imm = 0x5CA
movq %rbx, %rdi
callq 0xd138
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x12693
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 0x126b5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12cb8
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x12ca4
movq 0x50(%rax), %r12
testq %r12, %r12
je 0x12c57
cmpb $0x0, 0x49(%rax)
jne 0x12c57
movq (%r12), %r13
cmpq 0x8(%r12), %r13
je 0x12c1d
movq (%r13), %r15
testq %r15, %r15
je 0x12c17
movq 0x20(%r15), %rdi
leaq 0x30(%r15), %rax
cmpq %rax, %rdi
je 0x12beb
movq (%rax), %rsi
incq %rsi
callq 0x42e0
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0x12c02
movq (%rax), %rsi
incq %rsi
callq 0x42e0
movl $0x50, %esi
movq %r15, %rdi
callq 0x42e0
movq $0x0, (%r13)
addq $0x8, %r13
jmp 0x12bc3
movq 0x40(%r14), %rax
movq 0x50(%rax), %r15
testq %r15, %r15
je 0x12c4b
movq (%r15), %rdi
testq %rdi, %rdi
je 0x12c3e
movq 0x10(%r15), %rsi
subq %rdi, %rsi
callq 0x42e0
movl $0x18, %esi
movq %r15, %rdi
callq 0x42e0
movq 0x40(%r14), %rax
movq $0x0, 0x50(%rax)
movq 0x40(%r14), %r15
testq %r15, %r15
je 0x12c9c
movq 0x20(%r15), %rdi
leaq 0x30(%r15), %rax
cmpq %rax, %rdi
je 0x12c78
movq (%rax), %rsi
incq %rsi
callq 0x42e0
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0x12c8f
movq (%rax), %rsi
incq %rsi
callq 0x42e0
movl $0x58, %esi
movq %r15, %rdi
callq 0x42e0
movq $0x0, 0x40(%r14)
movq %r14, %rdi
callq 0x41f0
movq %rax, %r14
cmpq %rbx, %rax
jne 0x12b9b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa2be(%rip), %rdi      # 0x1cfc8
callq 0x4340
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x4340
movq %rax, %r12
leaq 0x3468(%rip), %rsi      # 0x16190
movl $0x2, %edx
movq %rax, %rdi
callq 0x4340
movl 0x24(%r14), %esi
movq %r12, %rdi
callq 0x4560
leaq 0x2fd6(%rip), %rsi      # 0x15d1e
movl $0x1, %edx
movq %rax, %rdi
callq 0x4340
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x12d6b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
cmpq $0x0, 0x48(%r14)
je 0x12db4
movq 0xa24f(%rip), %r12      # 0x1cfc8
leaq 0x4094(%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 0x406e(%rip), %rsi      # 0x16e15
movl $0x1, %edx
movq %rax, %rdi
callq 0x4340
movq 0xa20d(%rip), %rdi      # 0x1cfc8
leaq 0x3c4d(%rip), %rsi      # 0x16a0f
movl $0x1, %edx
callq 0x4340
movq 0x50(%r14), %rax
testq %rax, %rax
je 0x12e00
movq (%rax), %r12
movq 0x50(%r14), %rax
cmpq 0x8(%rax), %r12
je 0x12e00
incl %ebx
movq (%r12), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x12cc2
addq $0x8, %r12
movq 0x50(%r14), %rax
cmpq 0x8(%rax), %r12
jne 0x12de4
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x12e27
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12b7e
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x12e5b
movq (%rdi), %rax
callq *0x28(%rax)
movq $0x0, 0x10(%rbx)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x12e69
callq 0x42c0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x12e77
callq 0x42c0
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x12e9d
movq %r15, %rdi
callq 0xe8fa
movl $0x220, %esi            # imm = 0x220
movq %r15, %rdi
callq 0x42e0
movq $0x0, 0x8(%rbx)
movq %r14, %rdi
callq 0x12fa8
movq 0x40(%rbx), %rdi
addq $0x50, %rbx
cmpq %rbx, %rdi
je 0x12ec2
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_O1/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 0x2b3e(%rip), %rdx      # 0x16a10
movq %rdx, %rsi
callq 0x6e3c
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe8d8
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x14090
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x50(%r15), %rax
testq %rax, %rax
je 0x140c5
movq (%rax), %r13
movq 0x50(%r15), %rax
cmpq 0x8(%rax), %r13
je 0x140c5
leal 0x1(%rbx), %ebp
movq (%r13), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x14032
addq $0x8, %r13
movq 0x50(%r15), %rax
cmpq 0x8(%rax), %r13
jne 0x140a9
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 0xe8d8
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1410b
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 0x1413a
jmp 0x14147
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14147
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14588
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_O1/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
cmpq $0x0, 0x20(%rdi)
jne 0x14218
movq 0x8e36(%rip), %rdi      # 0x1cff0
leaq 0x2f9b(%rip), %rsi      # 0x1715c
movl $0x3e, %edx
callq 0x4340
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2fc0(%rip), %rsi      # 0x1719b
leaq 0x2fc0(%rip), %rdx      # 0x171a2
leaq 0x8(%rsp), %rdi
callq 0x6e3c
leaq 0x4(%rsp), %rsi
movl $0x42, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0xd138
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x14218
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdi
callq 0xbba7
testl %eax, %eax
je 0x1428e
movq 0x8dc0(%rip), %rdi      # 0x1cff0
leaq 0x2f6c(%rip), %rsi      # 0x171a3
movl $0x1e, %edx
callq 0x4340
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2f4a(%rip), %rsi      # 0x1719b
leaq 0x2f4a(%rip), %rdx      # 0x171a2
leaq 0x8(%rsp), %rdi
callq 0x6e3c
leaq 0x4(%rsp), %rsi
movl $0x48, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0xd138
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1428e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x1429a
jmp 0x142b6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x142b9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x142b9
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x143a2
movq %r14, %rdi
movq %r15, %rsi
callq 0xe8d8
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14306
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movl $0x18, %edi
callq 0x42d0
movq %rax, %r14
movq %rax, %rdi
callq 0x13fc0
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x13fd0
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x14006
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x13fee
movq %r14, %rdi
callq 0x14026
movq %r14, %rdi
callq 0x14150
movl $0x18, %esi
movq %r14, %rdi
callq 0x42e0
movq 0x8(%rbx), %rdi
callq 0xe8ee
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r14, %rdi
jmp 0x14395
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1439a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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 0x143ca
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x6dac
jmp 0x143dc
leaq 0x263f(%rip), %rdx      # 0x16a10
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6e3c
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x40(%r14)
jne 0x1496a
movq 0x86df(%rip), %rdi      # 0x1cff0
leaq 0x22c4(%rip), %rsi      # 0x16bdc
movl $0x31, %edx
callq 0x4340
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x28ac(%rip), %rsi      # 0x171de
leaq 0x28b0(%rip), %rdx      # 0x171e9
movq %rsp, %rdi
callq 0x6e3c
leaq 0x24(%rsp), %rsi
movl $0x66, (%rsi)
movq %rsp, %rdi
callq 0xd138
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1496a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x40(%r14), %rax
testb $0x4, 0x20(%rax)
je 0x149fc
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 0x2838(%rip), %rsi      # 0x171ea
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 0x79f(%rip), %rsi       # 0x15178
movl $0x2, %edx
movq %rax, %rdi
callq 0x4340
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x149fc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
movq 0x85b0(%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 0x14a5d
jmp 0x14a6a
jmp 0x14a4c
jmp 0x14a4c
movq %rax, %rbx
jmp 0x14a6a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x14a6a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x854f(%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_O1/tobias93[P]piano/rtaudio/tests/playraw.cpp
// Function: usage()
void usage( void ) {
  // Error function in case of incorrect command-line
  // argument specifications
  std::cout << "\nuseage: playraw N fs file <device> <channelOffset>\n";
  std::cout << "    where N = number of channels,\n";
  std::cout << "    fs = the sample rate, \n";
  std::cout << "    file = the raw file to play,\n";
  std::cout << "    device = optional device to use (default = 0),\n";
  std::cout << "    and channelOffset = an optional channel offset on the device (default = 0).\n\n";
  exit( 0 );
}

// Assembly:
pushq %rbx
movq 0x79fc(%rip), %rbx      # 0xbfd0
leaq 0x4a29(%rip), %rsi      # 0x9004
movq %rbx, %rdi
callq 0x41f0
leaq 0x4a4f(%rip), %rsi      # 0x9039
movq %rbx, %rdi
callq 0x41f0
leaq 0x4a63(%rip), %rsi      # 0x905c
movq %rbx, %rdi
callq 0x41f0
leaq 0x4a70(%rip), %rsi      # 0x9078
movq %rbx, %rdi
callq 0x41f0
leaq 0x4a83(%rip), %rsi      # 0x909a
movq %rbx, %rdi
callq 0x41f0
leaq 0x4aa8(%rip), %rsi      # 0x90ce
movq %rbx, %rdi
callq 0x41f0
xorl %edi, %edi
callq 0x4280
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/tests/playraw.cpp
// Function: output(void*, void*, unsigned int, double, unsigned int, void*)
int output( void *outputBuffer, void * /*inputBuffer*/, unsigned int nBufferFrames,
            double /*streamTime*/, RtAudioStreamStatus /*status*/, void *data )
{
  OutputData *oData = (OutputData*) data;

  // In general, it's not a good idea to do file input in the audio
  // callback function but I'm doing it here because I don't know the
  // length of the file we are reading.
  unsigned int count = fread( outputBuffer, oData->channels * sizeof( MY_TYPE ), nBufferFrames, oData->fd);
  if ( count < nBufferFrames ) {
    unsigned int bytes = (nBufferFrames - count) * oData->channels * sizeof( MY_TYPE );
    unsigned int startByte = count * oData->channels * sizeof( MY_TYPE );
    memset( (char *)(outputBuffer)+startByte, 0, bytes );
    return 1;
  }

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r15
movl %edx, %ebx
movq %rdi, %r14
movl 0x8(%r8), %esi
addq %rsi, %rsi
movl %edx, %edx
movq (%r8), %rcx
callq 0x4300
xorl %ecx, %ecx
subl %eax, %ebx
jbe 0x467c
movl 0x8(%r15), %ecx
imull %ecx, %ebx
addl %ebx, %ebx
imull %ecx, %eax
addl %eax, %eax
addq %rax, %r14
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x4120
movl $0x1, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/getput.cc
// Function: main
int main()
{
	char ch;
	while (cin.get(ch))
        cout.put(ch);
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x2e03(%rip), %rdi      # 0x3fe0
leaq -0x19(%rbp), %rsi
callq 0x1070
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x122b
movq 0x2dd5(%rip), %rbx      # 0x3fd0
movq 0x2dde(%rip), %r14      # 0x3fe0
leaq -0x19(%rbp), %r15
movsbl -0x19(%rbp), %esi
movq %rbx, %rdi
callq 0x1030
movq %r14, %rdi
movq %r15, %rsi
callq 0x1070
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x1206
movq 0x2d9e(%rip), %rbx      # 0x3fd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a218(%rip), %rax     # 0x8c960
movq %rax, (%rbx)
leaq 0x42562(%rip), %rcx     # 0x74cb4
movl $0x4, %edx
movl $0xa, %r8d
xorl %esi, %esi
callq 0x2e640
testq %r15, %r15
je 0x32783
leaq 0x59ec0(%rip), %rsi     # 0x8c630
leaq 0x5a1f1(%rip), %rdx     # 0x8c968
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x2e430
jmp 0x32785
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 0x5a1ec(%rip), %rax     # 0x8c990
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
cmpq %r12, %rdi
je 0x327b5
callq 0x2e360
movq %r14, %rdi
callq 0x2e730
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32e82
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *(%rax)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x1a8(%rbp), %rdi
callq 0x2e440
leaq 0x42f61(%rip), %rsi     # 0x75dc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x2e440
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32e82
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 0x32eb5
callq 0x2e360
leaq -0x1a0(%rbp), %rsi
movq %rbx, %rdi
callq 0x2e660
movq 0x5b0dd(%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 0x32ef8
jmp 0x32ef8
jmp 0x32efd
movq %rax, %rbx
jmp 0x32f12
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32f12
callq 0x2e360
movq 0x5b08f(%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_O1/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 %rdi, %rbx
movq 0x40(%rdi), %r14
cmpl $0x0, 0x3c(%rdi)
jne 0x35348
leaq 0x57304(%rip), %rsi     # 0x8c630
leaq 0x58145(%rip), %rdx     # 0x8d478
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x2e430
movq %rax, %rdi
callq 0x3e32c
movq %rax, %r14
movl $0x50, %edi
callq 0x2e3a0
movq %rax, %r15
movl 0x3c(%rbx), %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x3526c
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x2e360
movq %rbx, %rdi
callq 0x2e730
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %edx, %edx
jle 0x35760
movl %edx, %r14d
movq %rsi, %r15
leaq -0x40(%rbp), %r13
leaq -0x50(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x39bbb
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2e4c0
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x3575b
callq 0x2e360
decl %r14d
jne 0x35734
movq %rbx, %rax
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 0x35783
callq 0x2e360
movq %r14, %rdi
callq 0x2e730
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x57304(%rip), %rax     # 0x8cae0
movq %rax, (%rbx)
movl $0x1, 0x58(%rbx)
leaq 0x4067d(%rip), %rcx     # 0x75e6a
movl $0x4, %edx
movl $0x9, %r8d
xorl %esi, %esi
callq 0x2e640
testq %r12, %r12
je 0x3581e
leaq 0x56e25(%rip), %rsi     # 0x8c630
leaq 0x57306(%rip), %rdx     # 0x8cb18
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x2e430
jmp 0x35820
xorl %eax, %eax
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x3582d
movq %rbx, 0x30(%rax)
testq %r15, %r15
je 0x3584c
leaq 0x56df7(%rip), %rsi     # 0x8c630
leaq 0x572d8(%rip), %rdx     # 0x8cb18
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x2e430
jmp 0x3584e
xorl %eax, %eax
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x3585b
movq %rbx, 0x30(%rax)
testq %r14, %r14
je 0x3587a
leaq 0x56dc9(%rip), %rsi     # 0x8c630
leaq 0x5727a(%rip), %rdx     # 0x8cae8
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x2e430
jmp 0x3587c
xorl %eax, %eax
movq %rax, 0x50(%rbx)
testq %rax, %rax
je 0x35889
movq %rbx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x570ee(%rip), %rax     # 0x8c990
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
cmpq %r13, %rdi
je 0x358b3
callq 0x2e360
movq %r14, %rdi
callq 0x2e730
nop
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: P4RegisterNode::toString[abi:cxx11]()
string P4RegisterNode::toString() {
    ostringstream oss;
    oss << "register " 
        << name_->toString() 
        << " {\n"
        << "  " << body_->toString()
        << "}\n\n";
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1d0(%rbp), %r15
movq %r15, %rdi
callq 0x2e550
leaq 0x3fb08(%rip), %rsi     # 0x75d90
movl $0x9, %edx
movq %r15, %rdi
callq 0x2e440
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *(%rax)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x1d0(%rbp), %rdi
callq 0x2e440
movq %rax, %r15
leaq 0x4390f(%rip), %rsi     # 0x79bcf
movl $0x3, %edx
movq %rax, %rdi
callq 0x2e440
leaq 0x41d9c(%rip), %rsi     # 0x78070
movl $0x2, %edx
movq %r15, %rdi
callq 0x2e440
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %r15, %rdi
callq 0x2e440
leaq 0x43d88(%rip), %rsi     # 0x7a08d
movl $0x3, %edx
movq %rax, %rdi
callq 0x2e440
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36324
callq 0x2e360
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36336
callq 0x2e360
leaq -0x1c8(%rbp), %rsi
movq %rbx, %rdi
callq 0x2e660
movq 0x57c5c(%rip), %rsi     # 0x8dfa8
leaq -0x1d0(%rbp), %rdi
callq 0x2e230
leaq -0x160(%rbp), %rdi
callq 0x2e150
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36395
jmp 0x36390
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36398
callq 0x2e360
jmp 0x36398
movq %rax, %rbx
jmp 0x363aa
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x363aa
callq 0x2e360
movq 0x57bf7(%rip), %rsi     # 0x8dfa8
leaq -0x1d0(%rbp), %rdi
callq 0x2e230
leaq -0x160(%rbp), %rdi
callq 0x2e150
movq %rbx, %rdi
callq 0x2e730
nop
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: NameListNode::toString[abi:cxx11]()
string NameListNode::toString() {
    if (nameList_) {
        ostringstream oss;
        oss << nameList_->toString()
            << ", "
            << name_->toString();
        return oss.str();
    } else {
        return name_->toString();
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x40(%rsi)
je 0x36c44
leaq -0x1d0(%rbp), %rdi
callq 0x2e550
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *(%rax)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x1d0(%rbp), %rdi
callq 0x2e440
movq %rax, %r15
leaq 0x413b9(%rip), %rsi     # 0x77f7f
movl $0x2, %edx
movq %rax, %rdi
callq 0x2e440
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %r15, %rdi
callq 0x2e440
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36c02
callq 0x2e360
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36c14
callq 0x2e360
leaq -0x1c8(%rbp), %rsi
movq %rbx, %rdi
callq 0x2e660
movq 0x5737e(%rip), %rsi     # 0x8dfa8
leaq -0x1d0(%rbp), %rdi
callq 0x2e230
leaq -0x160(%rbp), %rdi
callq 0x2e150
jmp 0x36c50
movq 0x48(%r14), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
callq *(%rax)
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36c7c
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36c84
callq 0x2e360
jmp 0x36c84
jmp 0x36c81
movq %rax, %rbx
jmp 0x36c96
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36c96
callq 0x2e360
movq 0x5730b(%rip), %rsi     # 0x8dfa8
leaq -0x1d0(%rbp), %rdi
callq 0x2e230
leaq -0x160(%rbp), %rdi
callq 0x2e150
movq %rbx, %rdi
callq 0x2e730
nop
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: TableReadStmtNode::TableReadStmtNode(TableReadStmtNode::MatchType, AstNode*)
TableReadStmtNode::TableReadStmtNode(MatchType matchType, AstNode* field) {
    nodeType_ = typeid(*this).name();
    matchType_ = matchType;
    field_ = field;
    field_->parent_ = this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %r15d
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 0x55e98(%rip), %rax     # 0x8cba0
movq %rax, (%rbx)
leaq 0x3f212(%rip), %rcx     # 0x75f24
movl $0x4, %edx
movl $0x13, %r8d
xorl %esi, %esi
callq 0x2e640
movl %r15d, 0x3c(%rbx)
movq %r14, 0x40(%rbx)
movq %rbx, 0x30(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x55c4d(%rip), %rax     # 0x8c990
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
cmpq %r12, %rdi
je 0x36d54
callq 0x2e360
movq %r14, %rdi
callq 0x2e730
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: TableReadStmtNode::toString[abi:cxx11]()
string TableReadStmtNode::toString() {
    ostringstream oss;
    oss << "    " << field_->toString() << " : ";
    switch(matchType_) {
        case EXACT: oss << "exact"; break;
        case TERNARY: oss << "ternary"; break;
    }
    oss << ";\n";
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1b0(%rbp), %r15
movq %r15, %rdi
callq 0x2e550
leaq 0x3f026(%rip), %rsi     # 0x75dae
movl $0x4, %edx
movq %r15, %rdi
callq 0x2e440
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x1b0(%rbp), %rdi
callq 0x2e440
leaq 0x42f7f(%rip), %rsi     # 0x79d3c
movl $0x3, %edx
movq %rax, %rdi
callq 0x2e440
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36ddc
callq 0x2e360
movl 0x3c(%r14), %eax
testl %eax, %eax
je 0x36df7
cmpl $0x1, %eax
jne 0x36e0f
movl $0x7, %edx
leaq 0x3efc4(%rip), %rsi     # 0x75db9
jmp 0x36e03
movl $0x5, %edx
leaq 0x3efb0(%rip), %rsi     # 0x75db3
leaq -0x1b0(%rbp), %rdi
callq 0x2e440
leaq 0x3f00f(%rip), %rsi     # 0x75e25
leaq -0x1b0(%rbp), %rdi
movl $0x2, %edx
callq 0x2e440
leaq -0x1a8(%rbp), %rsi
movq %rbx, %rdi
callq 0x2e660
movq 0x5716b(%rip), %rsi     # 0x8dfa8
leaq -0x1b0(%rbp), %rdi
callq 0x2e230
leaq -0x140(%rbp), %rdi
callq 0x2e150
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36e7f
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36e82
callq 0x2e360
jmp 0x36e82
movq %rax, %rbx
movq 0x5711f(%rip), %rsi     # 0x8dfa8
leaq -0x1b0(%rbp), %rdi
callq 0x2e230
leaq -0x140(%rbp), %rdi
callq 0x2e150
movq %rbx, %rdi
callq 0x2e730
nop
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: TableReadStmtsNode::toString[abi:cxx11]()
string TableReadStmtsNode::toString() {
    ostringstream oss;
    for (auto rsn : *list_) {
        oss << rsn->toString();
    }
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x2e550
movq 0x40(%r14), %rax
movq (%rax), %r12
movq 0x8(%rax), %rbx
cmpq %rbx, %r12
je 0x36f85
leaq -0x40(%rbp), %r13
leaq -0x50(%rbp), %r14
leaq -0x1c8(%rbp), %r15
movq (%r12), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *(%rax)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %r15, %rdi
callq 0x2e440
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x36f7c
callq 0x2e360
addq $0x8, %r12
cmpq %rbx, %r12
jne 0x36f52
leaq -0x1c0(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2e660
movq 0x57009(%rip), %rsi     # 0x8dfa8
leaq -0x1c8(%rbp), %rdi
callq 0x2e230
leaq -0x158(%rbp), %rdi
callq 0x2e150
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36fce
movq %rax, %rbx
jmp 0x36fe4
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x36fe4
callq 0x2e360
movq 0x56fbd(%rip), %rsi     # 0x8dfa8
leaq -0x1c8(%rbp), %rdi
callq 0x2e230
leaq -0x158(%rbp), %rdi
callq 0x2e150
movq %rbx, %rdi
callq 0x2e730
nop
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: TableActionStmtsNode::toString[abi:cxx11]()
string TableActionStmtsNode::toString() {
    ostringstream oss;
    for (auto asn : *list_) {
        oss << asn->toString();
    }
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x2e550
movq 0x40(%r14), %rax
movq (%rax), %r12
movq 0x8(%rax), %rbx
cmpq %rbx, %r12
je 0x3729f
leaq -0x40(%rbp), %r13
leaq -0x50(%rbp), %r14
leaq -0x1c8(%rbp), %r15
movq (%r12), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *(%rax)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %r15, %rdi
callq 0x2e440
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x37296
callq 0x2e360
addq $0x8, %r12
cmpq %rbx, %r12
jne 0x3726c
leaq -0x1c0(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2e660
movq 0x56cef(%rip), %rsi     # 0x8dfa8
leaq -0x1c8(%rbp), %rdi
callq 0x2e230
leaq -0x158(%rbp), %rdi
callq 0x2e150
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x372e8
movq %rax, %rbx
jmp 0x372fe
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x372fe
callq 0x2e360
movq 0x56ca3(%rip), %rsi     # 0x8dfa8
leaq -0x1c8(%rbp), %rdi
callq 0x2e230
leaq -0x158(%rbp), %rdi
callq 0x2e150
movq %rbx, %rdi
callq 0x2e730
nop
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: FieldDecsNode::toString[abi:cxx11]()
string FieldDecsNode::toString() {
    ostringstream oss;
    for (auto fdn : *list_) {
        oss << fdn->toString() << endl;
    }
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x2e550
movq 0x40(%r14), %rax
movq (%rax), %r13
movq 0x8(%rax), %rbx
cmpq %rbx, %r13
je 0x37ef1
leaq -0x50(%rbp), %r14
leaq -0x1c8(%rbp), %r15
movq (%r13), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *(%rax)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %r15, %rdi
callq 0x2e440
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2e370
movsbl %al, %esi
movq %r12, %rdi
callq 0x2e040
movq %rax, %rdi
callq 0x2e2b0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x37ee8
callq 0x2e360
addq $0x8, %r13
cmpq %rbx, %r13
jne 0x37e90
leaq -0x1c0(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2e660
movq 0x5609d(%rip), %rsi     # 0x8dfa8
leaq -0x1c8(%rbp), %rdi
callq 0x2e230
leaq -0x158(%rbp), %rdi
callq 0x2e150
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37f3a
movq %rax, %r14
jmp 0x37f54
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x37f54
callq 0x2e360
movq 0x5604d(%rip), %rsi     # 0x8dfa8
leaq -0x1c8(%rbp), %rdi
callq 0x2e230
leaq -0x158(%rbp), %rdi
callq 0x2e150
movq %r14, %rdi
callq 0x2e730
nop
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: HeaderTypeDeclarationNode::HeaderTypeDeclarationNode(AstNode*, AstNode*, AstNode*)
HeaderTypeDeclarationNode::HeaderTypeDeclarationNode(AstNode* name,
                                                     AstNode* field_decs,
                                                     AstNode* other_stmts) {
    nodeType_ = typeid(*this).name();
    name_ = dynamic_cast<NameNode*>(name);
    field_decs_ = dynamic_cast<FieldDecsNode*>(field_decs);
    other_stmts_ = other_stmts;
}

// 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 0x54cac(%rip), %rax     # 0x8cc78
movq %rax, (%rbx)
leaq 0x3df92(%rip), %rcx     # 0x75f68
movl $0x4, %edx
movl $0x1b, %r8d
xorl %esi, %esi
callq 0x2e640
testq %r12, %r12
je 0x38007
leaq 0x5463c(%rip), %rsi     # 0x8c630
leaq 0x549e5(%rip), %rdx     # 0x8c9e0
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x2e430
jmp 0x38009
xorl %eax, %eax
movq %rax, 0x40(%rbx)
testq %r15, %r15
je 0x3802c
leaq 0x54617(%rip), %rsi     # 0x8c630
leaq 0x54c60(%rip), %rdx     # 0x8cc80
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x2e430
jmp 0x3802e
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movq %r14, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x54941(%rip), %rax     # 0x8c990
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
cmpq %r13, %rdi
je 0x38060
callq 0x2e360
movq %r14, %rdi
callq 0x2e730
// File: /workspace/github_cpp_makefile_star2_O1/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: HeaderTypeDeclarationNode::toString[abi:cxx11]()
string HeaderTypeDeclarationNode::toString() {
    ostringstream oss;
    oss << "header_type " << name_->toString() << " {\n";
    oss << "  fields {\n";
    oss << field_decs_->toString();
    oss << "  }\n";
    oss << other_stmts_->toString();
    oss << "}\n\n";
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1b0(%rbp), %r15
movq %r15, %rdi
callq 0x2e550
leaq 0x3dd51(%rip), %rsi     # 0x75de5
movl $0xc, %edx
movq %r15, %rdi
callq 0x2e440
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x1b0(%rbp), %rdi
callq 0x2e440
leaq 0x41b06(%rip), %rsi     # 0x79bcf
movl $0x3, %edx
movq %rax, %rdi
callq 0x2e440
leaq -0x28(%rbp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x380e8
callq 0x2e360
leaq 0x3dd03(%rip), %rsi     # 0x75df2
leaq -0x1b0(%rbp), %rdi
movl $0xb, %edx
callq 0x2e440
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x1b0(%rbp), %rdi
callq 0x2e440
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3812f
callq 0x2e360
leaq 0x3f280(%rip), %rsi     # 0x773b6
leaq -0x1b0(%rbp), %rdi
movl $0x4, %edx
callq 0x2e440
movq 0x50(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x1b0(%rbp), %rdi
callq 0x2e440
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x38176
callq 0x2e360
leaq 0x41f10(%rip), %rsi     # 0x7a08d
leaq -0x1b0(%rbp), %rdi
movl $0x3, %edx
callq 0x2e440
leaq -0x1a8(%rbp), %rsi
movq %rbx, %rdi
callq 0x2e660
movq 0x55e04(%rip), %rsi     # 0x8dfa8
leaq -0x1b0(%rbp), %rdi
callq 0x2e230
leaq -0x140(%rbp), %rdi
callq 0x2e150
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x381d1
jmp 0x381fa
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
jne 0x381f3
jmp 0x381fd
jmp 0x381fa
jmp 0x381fa
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x381fd
callq 0x2e360
jmp 0x381fd
movq %rax, %rbx
movq 0x55da4(%rip), %rsi     # 0x8dfa8
leaq -0x1b0(%rbp), %rdi
callq 0x2e230
leaq -0x140(%rbp), %rdi
callq 0x2e150
movq %rbx, %rdi
callq 0x2e730