LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbecc
leaq 0x18(%rbx), %rdi
callq 0x4090
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xbed9
callq 0x43a0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xbee7
callq 0x43a0
addq $0x18, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x40b0
movq %rax, %rdi
callq 0x5dae
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x8(%rdi)
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x4530
movq (%r15), %rsi
pushq $0x14
popq %rdx
movq %rbx, %rdi
callq 0x4060
movq (%rbx), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rbx,%rax)
je 0xc001
movq 0xe03b(%rip), %rdi      # 0x19ff0
leaq 0x6ae7(%rip), %rsi      # 0x12aa3
callq 0x4290
movq %rax, %rdi
movq %r15, %rsi
callq 0x4250
leaq 0x6b93(%rip), %rsi      # 0x12b66
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x5caa
leaq 0xc(%rsp), %rsi
movl $0x3f, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0xb17a
leaq 0x10(%rsp), %rdi
callq 0x4150
movl $0x110, %edi            # imm = 0x110
callq 0x42b0
movq %rax, %r15
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x4110
movq %r15, 0x218(%r14)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4150
jmp 0xc051
jmp 0xc04e
movq %rax, %r14
movl $0x110, %esi            # imm = 0x110
movq %r15, %rdi
callq 0x42c0
jmp 0xc051
movq %rax, %r14
movq %rbx, %rdi
callq 0x4470
movq %r14, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x4440
movq 0x218(%r14), %rdi
testq %rdi, %rdi
je 0xc0a9
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xc0b7
callq 0x43a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4470
movq %rax, %rdi
callq 0x5dae
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
jne 0xc1e5
movq 0xde50(%rip), %rdi      # 0x19ff0
leaq 0x69cb(%rip), %rsi      # 0x12b72
callq 0x4290
leaq 0x6a02(%rip), %rsi      # 0x12bb5
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x5caa
leaq 0xc(%rsp), %rsi
movl $0x9f, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0xb17a
leaq 0x10(%rsp), %rdi
callq 0x4150
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
addq $0x60, %rbx
movq %rbx, %rdx
callq 0x7b88
testl %eax, %eax
je 0xc241
movq 0xddf0(%rip), %rdi      # 0x19ff0
leaq 0x69b6(%rip), %rsi      # 0x12bbd
callq 0x4290
leaq 0x69a2(%rip), %rsi      # 0x12bb5
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x5caa
leaq 0xc(%rsp), %rsi
movl $0xa7, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0xb17a
leaq 0x10(%rsp), %rdi
callq 0x4150
movq %rbx, %rsi
callq 0xc26e
addq $0x30, %rsp
popq %rbx
retq
jmp 0xc253
jmp 0xc262
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4150
jmp 0xc265
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc188
cmpq $0x0, 0x48(%rbx)
jne 0xed12
movq 0xb31f(%rip), %rdi      # 0x19ff0
leaq 0x3f36(%rip), %rsi      # 0x12c0e
callq 0x4290
leaq 0x3ed1(%rip), %rsi      # 0x12bb5
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x5caa
leaq 0xc(%rsp), %rsi
movl $0x596, (%rsi)          # imm = 0x596
leaq 0x10(%rsp), %rdi
callq 0xb17a
leaq 0x10(%rsp), %rdi
callq 0x4150
leaq 0x40(%rbx), %r14
leaq 0x60(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x8bf6
movq (%rax), %rsi
movq 0x18(%rbx), %rdx
movq %rbx, %rdi
callq 0xdf6c
movq 0x18(%rbx), %rax
cmpl $0x0, 0x24(%rax)
jne 0xed56
movq %r15, %rdi
movq %r14, %rsi
callq 0x8bf6
movq (%rax), %rax
movl 0x40(%rax), %eax
movq 0x18(%rbx), %rcx
movl %eax, 0x24(%rcx)
pushq $0x18
popq %rdi
callq 0x42b0
movq %rax, %r14
movq %rax, %rdi
callq 0x10348
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x10354
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1038a
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x10372
movq %r14, %rdi
callq 0x103aa
movq %r14, %rdi
callq 0x1048e
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x42c0
movq 0x8(%rbx), %rdi
callq 0xc078
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4150
jmp 0xeddd
movq %rax, %rbx
jmp 0xeddd
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x42c0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2449(%rip), %rsi      # 0x11246
callq 0x4320
movq %rax, 0x30(%r14)
testq %rax, %rax
jne 0xeea5
movq 0xb1da(%rip), %rdi      # 0x19ff0
leaq 0x4146(%rip), %rsi      # 0x12f63
callq 0x4290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4250
leaq 0x221b(%rip), %rdi      # 0x1104f
callq 0x4350
testq %rax, %rax
jne 0xee6f
movq 0xb1ab(%rip), %rdi      # 0x19ff0
leaq 0x414e(%rip), %rsi      # 0x12f9a
callq 0x4290
leaq 0x21f7(%rip), %rsi      # 0x1104f
movq %rax, %rdi
callq 0x4290
leaq 0x414e(%rip), %rsi      # 0x12fb5
movq %rax, %rdi
callq 0x4290
leaq 0x3d3f(%rip), %rsi      # 0x12bb5
leaq 0x8(%rsp), %rbx
leaq 0x3(%rsp), %rdx
movq %rbx, %rdi
callq 0x5caa
leaq 0x4(%rsp), %rsi
movl $0x5ca, (%rsi)          # imm = 0x5CA
movq %rbx, %rdi
callq 0xb17a
leaq 0x8(%rsp), %rdi
callq 0x4150
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4150
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rsi), %r15
addq $0x8, %rbx
pushq $0x58
popq %r14
pushq $0x50
popq %r13
cmpq %rbx, %r15
je 0xf29a
movq 0x40(%r15), %rbp
testq %rbp, %rbp
je 0xf28a
movq 0x50(%rbp), %r12
testq %r12, %r12
je 0xf272
cmpb $0x0, 0x49(%rbp)
jne 0xf272
movq (%r12), %r14
cmpq 0x8(%r12), %r14
je 0xf245
movq (%r14), %rbp
testq %rbp, %rbp
je 0xf23f
movq %rbp, %rdi
callq 0xf52c
movq %rbp, %rdi
movq %r13, %rsi
callq 0x42c0
andq $0x0, (%r14)
addq $0x8, %r14
jmp 0xf219
movq 0x40(%r15), %rax
movq 0x50(%rax), %rbp
testq %rbp, %rbp
je 0xf25a
movq %rbp, %rdi
callq 0xfa92
movq %rbp, %rdi
pushq $0x18
popq %rsi
callq 0x42c0
movq 0x40(%r15), %rbp
andq $0x0, 0x50(%rbp)
pushq $0x58
popq %r14
movq %rbp, %rdi
callq 0xf542
movq %rbp, %rdi
movq %r14, %rsi
callq 0x42c0
andq $0x0, 0x40(%r15)
movq %r15, %rdi
callq 0x41e0
movq %rax, %r15
jmp 0xf1f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leal (,%rbx,4), %eax
movslq %eax, %rsi
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r12
pushq $0x20
popq %rdx
movq %r12, %rdi
callq 0x4300
movq 0xace1(%rip), %rdi      # 0x19fc8
movq %r12, %rsi
callq 0x4250
movq %rax, %rdi
movq %r14, %rsi
callq 0x4250
leaq 0x2e95(%rip), %rsi      # 0x12196
movq %rax, %rdi
callq 0x4290
movl 0x24(%r14), %esi
movq %rax, %rdi
callq 0x4540
leaq 0x2a02(%rip), %rsi      # 0x11d1e
movq %rax, %rdi
callq 0x4290
leaq 0x8(%rsp), %rdi
callq 0x4150
cmpq $0x0, 0x48(%r14)
je 0xf363
movq 0xac8c(%rip), %rdi      # 0x19fc8
leaq 0x3ad1(%rip), %rsi      # 0x12e14
callq 0x4290
movq 0x48(%r14), %rsi
movq %rax, %rdi
callq 0x4250
leaq 0x3aba(%rip), %rsi      # 0x12e15
movq %rax, %rdi
callq 0x4290
movq 0xac5e(%rip), %rdi      # 0x19fc8
leaq 0x369e(%rip), %rsi      # 0x12a0f
callq 0x4290
movq 0x50(%r14), %rax
testq %rax, %rax
je 0xf3a2
movq (%rax), %r12
incl %ebx
cmpq 0x8(%rax), %r12
je 0xf3a2
movq (%r12), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0xf2aa
addq $0x8, %r12
movq 0x50(%r14), %rax
jmp 0xf384
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4150
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf1d2
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xf3ec
movq (%rdi), %rax
callq *0x28(%rax)
andq $0x0, 0x10(%rbx)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xf3fa
callq 0x42a0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xf408
callq 0x42a0
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0xf42b
movq %r15, %rdi
callq 0xc084
movl $0x220, %esi            # imm = 0x220
movq %r15, %rdi
callq 0x42c0
andq $0x0, 0x8(%rbx)
movq %r14, %rdi
callq 0xf558
addq $0x40, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4150
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc062
leaq 0x8(%rsp), %rdi
callq 0x4150
movq 0x50(%r15), %rax
testq %rax, %rax
je 0x1042f
movq (%rax), %r12
leal 0x1(%rbx), %ebp
cmpq 0x8(%rax), %r12
je 0x1042f
movq (%r12), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x103b6
addq $0x8, %r12
movq 0x50(%r15), %rax
jmp 0x10411
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 0xc062
leaq 0x8(%rsp), %rdi
callq 0x4150
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10479
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4150
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x48
popq %rdi
callq 0x42b0
movq %rax, %r14
movq %rax, %rdi
callq 0x107e0
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
pushq $0x48
popq %rsi
movq %r14, %rdi
callq 0x42c0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0x10537
movq 0x9afe(%rip), %rdi      # 0x19ff0
leaq 0x2c31(%rip), %rsi      # 0x1312a
callq 0x4290
leaq 0x2c64(%rip), %rsi      # 0x13169
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x5caa
leaq 0xc(%rsp), %rsi
movl $0x42, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0xb17a
leaq 0x10(%rsp), %rdi
callq 0x4150
movq 0x20(%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0xa1b0
testl %eax, %eax
je 0x1058c
movq 0x9aa5(%rip), %rdi      # 0x19ff0
leaq 0x2c1f(%rip), %rsi      # 0x13171
callq 0x4290
leaq 0x2c0b(%rip), %rsi      # 0x13169
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x5caa
leaq 0xc(%rsp), %rsi
movl $0x48, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0xb17a
leaq 0x10(%rsp), %rdi
callq 0x4150
addq $0x30, %rsp
popq %rbx
retq
jmp 0x10596
jmp 0x105a5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4150
jmp 0x105a8
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1066a
movq %r14, %rdi
movq %r15, %rsi
callq 0xc062
movq %rsp, %rdi
callq 0x4150
pushq $0x18
popq %rdi
callq 0x42b0
movq %rax, %r14
movq %rax, %rdi
callq 0x10348
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x10354
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1038a
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x10372
movq %r14, %rdi
callq 0x103aa
movq %r14, %rdi
callq 0x1048e
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x42c0
movq 0x8(%rbx), %rdi
callq 0xc078
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x42c0
jmp 0x10661
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4150
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4400
movq 0x40(%r14), %rax
testq %rax, %rax
jne 0x10aa2
movq 0x9593(%rip), %rdi      # 0x19ff0
leaq 0x2178(%rip), %rsi      # 0x12bdc
callq 0x4290
leaq 0x273c(%rip), %rsi      # 0x131ac
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5caa
leaq 0x34(%rsp), %rsi
movl $0x66, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0xb17a
leaq 0x10(%rsp), %rdi
callq 0x4150
movq 0x40(%r14), %rax
testb $0x4, 0x20(%rax)
je 0x10b07
shll $0x2, %ebp
movslq %ebp, %rsi
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x10(%rsp), %rdi
pushq $0x20
popq %rdx
callq 0x4300
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4250
leaq 0x26de(%rip), %rsi      # 0x131b8
movq %rax, %rdi
callq 0x4290
movq 0x40(%r14), %rsi
movq %rax, %rdi
callq 0x4250
leaq 0x683(%rip), %rsi       # 0x11178
movq %rax, %rdi
callq 0x4290
leaq 0x10(%rsp), %rdi
callq 0x4150
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x44c0
leaq 0x38(%rsp), %rdi
callq 0x40a0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x10b38
jmp 0x10b33
jmp 0x10b33
movq %rax, %rbx
jmp 0x10b45
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4150
leaq 0x38(%rsp), %rdi
callq 0x40a0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7a6c(%rip), %rbx      # 0xbfd0
leaq 0x3a99(%rip), %rsi      # 0x8004
movq %rbx, %rdi
callq 0x41d0
leaq 0x3abf(%rip), %rsi      # 0x8039
movq %rbx, %rdi
callq 0x41d0
leaq 0x3ad3(%rip), %rsi      # 0x805c
movq %rbx, %rdi
callq 0x41d0
leaq 0x3ae0(%rip), %rsi      # 0x8078
movq %rbx, %rdi
callq 0x41d0
leaq 0x3af3(%rip), %rsi      # 0x809a
movq %rbx, %rdi
callq 0x41d0
leaq 0x3b18(%rip), %rsi      # 0x80ce
movq %rbx, %rdi
callq 0x41d0
xorl %edi, %edi
callq 0x4260
// File: /workspace/github_cpp_makefile_star2_O2/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 0x42e0
xorl %ecx, %ecx
subl %eax, %ebx
jbe 0x460a
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 0x4110
pushq $0x1
popq %rcx
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2e13(%rip), %rbx      # 0x3fe0
leaq -0x19(%rbp), %r14
movq 0x2df8(%rip), %r15      # 0x3fd0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x11ff
movsbl -0x19(%rbp), %esi
movq %r15, %rdi
callq 0x1030
jmp 0x11d8
movq 0x2dca(%rip), %rdi      # 0x3fd0
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x448c4
leaq 0x5056d(%rip), %rax     # 0x949c0
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x3382e(%rip), %rsi     # 0x77c8f
callq 0x41850
testq %r15, %r15
je 0x44485
leaq 0x5021e(%rip), %rsi     # 0x94690
leaq 0x5054f(%rip), %rdx     # 0x949c8
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x41480
jmp 0x44487
xorl %eax, %eax
movq %rax, 0x40(%rbx)
movq %r14, 0x48(%rbx)
movq %rbx, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x44900
movq %r14, %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x415a0
movq 0x40(%r14), %rsi
testq %rsi, %rsi
je 0x44972
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *(%rax)
leaq -0x1a8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x41380
leaq 0x34443(%rip), %rsi     # 0x78da4
movq %rax, %rdi
callq 0x413d0
leaq -0x30(%rbp), %rdi
callq 0x418c8
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *(%rax)
leaq -0x1a8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x41380
leaq -0x30(%rbp), %rdi
callq 0x418c8
leaq -0x1a0(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1a8(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x449c8
jmp 0x449c8
jmp 0x449cd
movq %rax, %rbx
jmp 0x449d9
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x418c8
leaq -0x1a8(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x46c45
movq %rdi, %r14
leaq 0x4da6b(%rip), %rsi     # 0x94690
leaq 0x4e8ac(%rip), %rdx     # 0x954d8
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x41480
movq %rax, %rdi
callq 0x4dc0e
movq %rax, %rbx
movl 0x3c(%r14), %r15d
pushq $0x50
popq %rdi
callq 0x413f0
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x46ba0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x413a0
movq %rbx, %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
xorl %r12d, %r12d
testl %edx, %edx
cmovgl %edx, %r12d
leaq -0x40(%rbp), %r15
subl $0x1, %r12d
jb 0x46f82
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x49f9c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x41500
movq %r15, %rdi
callq 0x418c8
jmp 0x46f59
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x418c8
movq %r14, %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x448c4
leaq 0x4db77(%rip), %rax     # 0x94b40
movq %rax, (%rbx)
movl $0x1, 0x58(%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x31e6c(%rip), %rsi     # 0x78e4a
callq 0x41850
testq %r12, %r12
je 0x4700f
leaq 0x4d6a1(%rip), %rsi     # 0x94690
leaq 0x4db82(%rip), %rdx     # 0x94b78
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x41480
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x47014
movq %rbx, 0x30(%rax)
jmp 0x47014
andq $0x0, 0x40(%rbx)
testq %r15, %r15
je 0x47040
leaq 0x4d670(%rip), %rsi     # 0x94690
leaq 0x4db51(%rip), %rdx     # 0x94b78
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x41480
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x47045
movq %rbx, 0x30(%rax)
jmp 0x47045
andq $0x0, 0x48(%rbx)
testq %r14, %r14
je 0x47071
leaq 0x4d63f(%rip), %rsi     # 0x94690
leaq 0x4daf0(%rip), %rdx     # 0x94b48
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x41480
movq %rax, 0x50(%rbx)
testq %rax, %rax
je 0x47076
movq %rbx, 0x30(%rax)
jmp 0x47076
andq $0x0, 0x50(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x44900
movq %r14, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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 0x415a0
leaq 0x316e2(%rip), %rsi     # 0x78d70
movq %r15, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *(%rax)
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x355a6(%rip), %rsi     # 0x7cc5f
movq %rax, %rdi
callq 0x413d0
leaq 0x33988(%rip), %rsi     # 0x7b050
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x35a2a(%rip), %rsi     # 0x7d11d
movq %rax, %rdi
callq 0x413d0
leaq -0x38(%rbp), %rdi
callq 0x418c8
leaq -0x58(%rbp), %rdi
callq 0x418c8
leaq -0x1c8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1d0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x47750
jmp 0x4774b
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x418c8
jmp 0x47753
movq %rax, %rbx
jmp 0x4775c
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x418c8
leaq -0x1d0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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 0x47d68
leaq -0x1d0(%rbp), %rdi
callq 0x415a0
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *(%rax)
leaq -0x1d0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x41380
leaq 0x3324a(%rip), %rsi     # 0x7af5f
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq -0x38(%rbp), %rdi
callq 0x418c8
leaq -0x58(%rbp), %rdi
callq 0x418c8
leaq -0x1c8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1d0(%rbp), %rdi
callq 0x410e0
jmp 0x47d74
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 0x47d97
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x418c8
jmp 0x47d9f
jmp 0x47d9c
movq %rax, %rbx
jmp 0x47da8
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x418c8
leaq -0x1d0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
callq 0x448c4
leaq 0x4ce25(%rip), %rax     # 0x94c00
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x3111b(%rip), %rsi     # 0x78f04
callq 0x41850
movl %r15d, 0x3c(%rbx)
movq %r14, 0x40(%rbx)
movq %rbx, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x44900
movq %r14, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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 0x415a0
leaq 0x30f4a(%rip), %rsi     # 0x78d8e
movq %r15, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x34f5d(%rip), %rsi     # 0x7cdcc
movq %rax, %rdi
callq 0x413d0
leaq -0x38(%rbp), %rdi
callq 0x418c8
movl 0x3c(%r14), %eax
testl %eax, %eax
je 0x47e96
cmpl $0x1, %eax
jne 0x47ea9
leaq 0x30f05(%rip), %rsi     # 0x78d99
jmp 0x47e9d
leaq 0x30ef6(%rip), %rsi     # 0x78d93
leaq -0x1b0(%rbp), %rdi
callq 0x413d0
leaq 0x30f55(%rip), %rsi     # 0x78e05
leaq -0x1b0(%rbp), %rdi
callq 0x413d0
leaq -0x1a8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1b0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x47ef8
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x418c8
jmp 0x47efb
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x198, %rsp            # imm = 0x198
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x1c0(%rbp), %r14
movq %r14, %rdi
callq 0x415a0
movq 0x40(%r15), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
leaq -0x48(%rbp), %r15
cmpq %r13, %r12
je 0x47fb4
movq (%r12), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x41380
movq %r15, %rdi
callq 0x418c8
addq $0x8, %r12
jmp 0x47f8a
leaq -0x1b8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1c0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x47fe6
movq %rax, %rbx
jmp 0x47ff7
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x418c8
leaq -0x1c0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x198, %rsp            # imm = 0x198
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x1c0(%rbp), %r14
movq %r14, %rdi
callq 0x415a0
movq 0x40(%r15), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
leaq -0x48(%rbp), %r15
cmpq %r13, %r12
je 0x481d6
movq (%r12), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x41380
movq %r15, %rdi
callq 0x418c8
addq $0x8, %r12
jmp 0x481ac
leaq -0x1b8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1c0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x48208
movq %rax, %rbx
jmp 0x48219
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x418c8
leaq -0x1c0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: TableNode::toString[abi:cxx11]()
string TableNode::toString() {
    ostringstream oss;
    if(pragma_.compare("")!=0) {
        oss << pragma_ << "\n";
    }
    oss << "table " << name_->toString() << " {\n";
    if (reads_ && reads_->list_->size() > 0) {
        oss << "  reads {\n"
            << reads_->toString()
            << "  }\n";
    }
    oss << "  actions {\n"
        << actions_->toString()
        << "  }\n";
    for (auto str : options_) {
        oss << "  " << str << ";\n";
    }
    oss << "}\n\n";
    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, -0x50(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x415a0
leaq 0x70(%r14), %rbx
leaq 0x3245d(%rip), %rsi     # 0x7a8bb
movq %rbx, %rdi
callq 0x41130
testl %eax, %eax
je 0x48488
leaq -0x1c8(%rbp), %rdi
movq %rbx, %rsi
callq 0x41380
leaq 0x30924(%rip), %rsi     # 0x78da4
movq %rax, %rdi
callq 0x413d0
leaq 0x30917(%rip), %rsi     # 0x78da6
leaq -0x1c8(%rbp), %rdi
callq 0x413d0
movq %rax, %rbx
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x48(%rbp), %rdi
callq *(%rax)
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x41380
leaq 0x347a1(%rip), %rsi     # 0x7cc5f
movq %rax, %rdi
callq 0x413d0
leaq -0x48(%rbp), %rdi
callq 0x418c8
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x4852c
movq 0x40(%rax), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x4852c
leaq 0x308c1(%rip), %rsi     # 0x78dad
leaq -0x1c8(%rbp), %rdi
callq 0x413d0
movq %rax, %rbx
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x48(%rbp), %rdi
callq *(%rax)
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x41380
leaq 0x31e7b(%rip), %rsi     # 0x7a396
movq %rax, %rdi
callq 0x413d0
leaq -0x48(%rbp), %rdi
callq 0x418c8
leaq 0x30885(%rip), %rsi     # 0x78db8
leaq -0x1c8(%rbp), %rdi
callq 0x413d0
movq %rax, %rbx
movq 0x50(%r14), %rsi
movq (%rsi), %rax
leaq -0x48(%rbp), %rdi
callq *(%rax)
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x41380
leaq 0x31e34(%rip), %rsi     # 0x7a396
movq %rax, %rdi
callq 0x413d0
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x418c8
movq 0x58(%r14), %r12
movq 0x60(%r14), %r14
leaq -0x1c8(%rbp), %r13
leaq 0x30879(%rip), %rbx     # 0x78e05
cmpq %r14, %r12
je 0x485cf
movq %r15, %rdi
movq %r12, %rsi
callq 0x415b0
movq %r13, %rdi
leaq 0x32aaa(%rip), %rsi     # 0x7b050
callq 0x413d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41380
movq %rax, %rdi
movq %rbx, %rsi
callq 0x413d0
movq %r15, %rdi
callq 0x418c8
addq $0x20, %r12
jmp 0x4858c
leaq 0x34b47(%rip), %rsi     # 0x7d11d
leaq -0x1c8(%rbp), %rdi
callq 0x413d0
leaq -0x1c0(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x416b0
leaq -0x1c8(%rbp), %rdi
callq 0x410e0
movq -0x50(%rbp), %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x48622
jmp 0x48627
jmp 0x48622
jmp 0x48622
jmp 0x48627
jmp 0x48627
jmp 0x48622
movq %rax, %rbx
jmp 0x48633
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x418c8
leaq -0x1c8(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: TableNode::transformPragma()
void TableNode::transformPragma() {
    if(pragma_.compare("")!=0 && !pragmaTransformed_) {
        std::vector<string> tmp_v;
        boost::algorithm::split(tmp_v, pragma_, boost::algorithm::is_space());
        pragma_ = "";
        for(int i=0; i<tmp_v.size()-1; i++) {
            pragma_ += tmp_v[i];
            pragma_ += " ";            
        }
        int stage_num = stoi(tmp_v[tmp_v.size()-1]);
        stage_num ++;
        pragma_ += std::to_string(stage_num);

        pragmaTransformed_=true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x70(%rdi), %r14
leaq 0x32254(%rip), %rsi     # 0x7a8bb
movq %r14, %rdi
callq 0x41130
testl %eax, %eax
je 0x48765
cmpb $0x0, 0x90(%rbx)
jne 0x48765
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
leaq -0x70(%rbp), %r15
movq %r15, %rdi
callq 0x418a0
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0x49dfb
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rdx
pushq $0x1
popq %rcx
movq %r14, %rsi
callq 0x49d6f
leaq -0x48(%rbp), %rdi
callq 0x415e0
leaq -0x70(%rbp), %rdi
callq 0x415e0
leaq 0x321e7(%rip), %rsi     # 0x7a8bb
movq %r14, %rdi
callq 0x41850
xorl %r12d, %r12d
leaq 0x3296b(%rip), %r15     # 0x7b051
xorl %r13d, %r13d
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rsi, %rax
sarq $0x5, %rax
decq %rax
cmpq %r13, %rax
jbe 0x4871f
addq %r12, %rsi
movq %r14, %rdi
callq 0x41870
movq %r14, %rdi
movq %r15, %rsi
callq 0x41840
incq %r13
addq $0x20, %r12
jmp 0x486e9
shlq $0x5, %rax
addq %rax, %rsi
pushq $0xa
popq %rdx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x49b15
incl %eax
leaq -0x70(%rbp), %rdi
movl %eax, %esi
callq 0x49e1c
leaq -0x70(%rbp), %rsi
movq %r14, %rdi
callq 0x41870
leaq -0x70(%rbp), %rdi
callq 0x418c8
movb $0x1, 0x90(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x49d44
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x418c8
jmp 0x487a7
jmp 0x487a4
jmp 0x487a4
jmp 0x487a4
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x415e0
jmp 0x48799
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x415e0
jmp 0x487a7
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x49d44
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x198, %rsp            # imm = 0x198
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x1c0(%rbp), %r14
movq %r14, %rdi
callq 0x415a0
movq 0x40(%r15), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
leaq -0x48(%rbp), %r15
cmpq %r13, %r12
je 0x489fe
movq (%r12), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x41380
movq %rax, %rdi
callq 0x41240
movq %r15, %rdi
callq 0x418c8
addq $0x8, %r12
jmp 0x489cc
leaq -0x1b8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1c0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x48a30
movq %rax, %rbx
jmp 0x48a41
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x418c8
leaq -0x1c0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x448c4
leaq 0x4c25f(%rip), %rax     # 0x94cd8
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x304c1(%rip), %rsi     # 0x78f48
callq 0x41850
testq %r12, %r12
je 0x48aab
leaq 0x4bbf8(%rip), %rsi     # 0x94690
leaq 0x4bfa1(%rip), %rdx     # 0x94a40
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x41480
jmp 0x48aad
xorl %eax, %eax
movq %rax, 0x40(%rbx)
testq %r15, %r15
je 0x48ad0
leaq 0x4bbd3(%rip), %rsi     # 0x94690
leaq 0x4c21c(%rip), %rdx     # 0x94ce0
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x41480
jmp 0x48ad2
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movq %r14, 0x50(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x44900
movq %r14, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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 0x415a0
leaq 0x302a3(%rip), %rsi     # 0x78dc5
movq %r15, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x34112(%rip), %rsi     # 0x7cc5f
movq %rax, %rdi
callq 0x413d0
leaq -0x38(%rbp), %rdi
callq 0x418c8
leaq 0x3026d(%rip), %rsi     # 0x78dd2
leaq -0x1b0(%rbp), %rdi
callq 0x413d0
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x1b0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x41380
leaq -0x38(%rbp), %rdi
callq 0x418c8
leaq 0x317f8(%rip), %rsi     # 0x7a396
leaq -0x1b0(%rbp), %rdi
callq 0x413d0
movq 0x50(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x1b0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x41380
leaq -0x38(%rbp), %rdi
callq 0x418c8
leaq 0x34546(%rip), %rsi     # 0x7d11d
leaq -0x1b0(%rbp), %rdi
callq 0x413d0
leaq -0x1a8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1b0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x48c19
jmp 0x48c27
jmp 0x48c19
jmp 0x48c27
jmp 0x48c27
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x418c8
jmp 0x48c2a
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: ArgsNode::deepCopy()
ArgsNode* ArgsNode::deepCopy() {
    auto newNode = new ArgsNode();
    for (auto bw : *list_) {
        auto newArg = bw->deepCopy();
        newNode->push_back(newArg);
    }

    return newNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x48
popq %rdi
callq 0x413f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x48f72
movq 0x40(%r14), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x48ffd
movq (%r14), %rdi
callq 0x46c04
movq %rbx, %rdi
movq %rax, %rsi
callq 0x44628
addq $0x8, %r14
jmp 0x48fdf
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x413a0
movq %r14, %rdi
callq 0x41790