LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/junhe[P]libpatterndetector/./pattern.h
// Function: PatternChain<PatternUnit>::show[abi:cxx11]()
string 
PatternChain<T>::show()
{
    typename vector<T>::const_iterator iter;
    ostringstream showstr;

    for ( iter = chain.begin();
            iter != chain.end();
            iter++ )
    {
        showstr << iter->show();
        /*
        vector<off_t>::const_iterator off_iter;
        for ( off_iter = (iter->seq).begin();
                off_iter != (iter->seq).end();
                off_iter++ )
        {
            cout << *off_iter << ", ";
        }
        cout << "^" << iter->cnt << endl;
        */
    }
    return showstr.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x2140
movq 0x8(%r14), %r12
leaq 0x8(%rsp), %r13
cmpq 0x10(%r14), %r12
je 0x25b3
movq (%r12), %rax
movq %r13, %rdi
movq %r12, %rsi
callq *(%rax)
movq %r15, %rdi
movq %r13, %rsi
callq 0x20f0
movq %r13, %rdi
callq 0x2080
addq $0x30, %r12
jmp 0x2588
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x2170
leaq 0x28(%rsp), %rdi
callq 0x2040
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x25e0
movq %rax, %rbx
jmp 0x25f2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2080
leaq 0x28(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/junhe[P]libpatterndetector/pattern.cpp
// Function: printVector[abi:cxx11](std::vector<long, std::allocator<long>>)
string
printVector( vector<off_t> vec )
{
    ostringstream oss;
    oss << "PrintVector: " ;
    vector<off_t>::const_iterator it;
    for ( it =  vec.begin() ;
          it != vec.end() ;
          it++ )
    {
        oss << *it << "," ;
    }
    oss << endl;
    return oss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2140
leaq 0x283d(%rip), %rsi      # 0x5100
movq %r15, %rdi
callq 0x2110
movq (%r14), %r13
leaq 0x8(%rsp), %r15
leaq 0x2834(%rip), %r12      # 0x510e
cmpq 0x8(%r14), %r13
je 0x28fd
movq (%r13), %rsi
movq %r15, %rdi
callq 0x2100
movq %rax, %rdi
movq %r12, %rsi
callq 0x2110
addq $0x8, %r13
jmp 0x28da
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2170
leaq 0x8(%rsp), %rdi
callq 0x2040
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2936
jmp 0x2936
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/junhe[P]libpatterndetector/pattern.cpp
// Function: buildDeltas(std::vector<long, std::allocator<long>>)
vector<off_t>
buildDeltas( vector<off_t> seq ) 
{
    vector<off_t>::iterator it;
    vector<off_t> deltas;
    //ostringstream oss;
    for ( it = seq.begin() ; it != seq.end() ; it++ )
    {
        if ( it > seq.begin() ) {
            deltas.push_back( *it - *(it-1) );
            //oss << (*it - *(it-1)) << "-";
        }
    }
    //mlog(IDX_WARN, "deltas:%s", oss.str().c_str());
    //cout << "in builddeltas: " << seq.size() << " " << deltas.size() << endl; 
    return deltas;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %r12
movq %rsp, %r15
cmpq 0x8(%r14), %r12
je 0x2993
cmpq (%r14), %r12
jbe 0x298d
movq (%r12), %rax
subq -0x8(%r12), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x40cc
addq $0x8, %r12
jmp 0x296a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2666
movq %r14, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/junhe[P]libpatterndetector/pattern.cpp
// Function: PatternElem::show[abi:cxx11]() const
string 
PatternElem::show() const
{
    vector<off_t>::const_iterator iter;
    ostringstream showstr;
    showstr << "( " ;
    for (iter = seq.begin();
            iter != seq.end();
            iter++ )
    {
        showstr << *iter << " ";
    }
    showstr << ") ^" << cnt << endl;
    return showstr.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2140
leaq 0x2702(%rip), %rsi      # 0x5110
movq %r15, %rdi
callq 0x2110
movq 0x8(%r14), %r13
leaq 0x8(%rsp), %r15
leaq 0x26eb(%rip), %r12      # 0x5111
cmpq 0x10(%r14), %r13
je 0x2a49
movq (%r13), %rsi
movq %r15, %rdi
callq 0x2100
movq %rax, %rdi
movq %r12, %rsi
callq 0x2110
addq $0x8, %r13
jmp 0x2a26
leaq 0x26c3(%rip), %rsi      # 0x5113
leaq 0x8(%rsp), %rdi
callq 0x2110
movq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x2090
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2170
leaq 0x8(%rsp), %rdi
callq 0x2040
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2a9b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/junhe[P]libpatterndetector/pattern.cpp
// Function: PatternUnit::compressRepeats()
void
PatternUnit::compressRepeats()
{
    if ( isSeqRepeating() && size() > 1 ) {
        cnt = size();
        off_t tmp = seq[0];
        seq.clear();
        seq.push_back(tmp);
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x2c30
testb %al, %al
je 0x2ca8
movq %rbx, %rdi
callq 0x29c6
cmpl $0x2, %eax
jl 0x2ca8
movl %eax, %eax
movq %rax, 0x20(%rbx)
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
cmpq %rax, 0x10(%rbx)
je 0x2c9e
movq %rax, 0x10(%rbx)
leaq 0x8(%rsp), %rsi
callq 0x3b42
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/junhe[P]libpatterndetector/pattern.cpp
// Function: PatternUnit::serialize[abi:cxx11]()
string 
PatternUnit::serialize()
{
    string buf; //let me put it in string and see if it works
    header_t seqbodysize;
    header_t totalsize;

    totalsize = bodySize(); 
    
    appendToBuffer(buf, &totalsize, sizeof(totalsize));
    appendToBuffer(buf, &init, sizeof(init));
    appendToBuffer(buf, &cnt, sizeof(cnt));
    seqbodysize = seq.size()*sizeof(off_t);
    appendToBuffer(buf, &(seqbodysize), sizeof(header_t));
    if (seqbodysize > 0 ) {
        appendToBuffer(buf, &seq[0], seqbodysize);
    }
    return buf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl 0x10(%rsi), %eax
subl 0x8(%rsi), %eax
andl $-0x8, %eax
addl $0x14, %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
pushq $0x4
popq %rdx
callq 0x2030
leaq 0x28(%r14), %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x2030
leaq 0x20(%r14), %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x2030
movl 0x10(%r14), %eax
subl 0x8(%r14), %eax
andl $-0x8, %eax
movq %rsp, %rsi
movl %eax, (%rsi)
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x2030
movl (%rsp), %edx
testl %edx, %edx
jle 0x2d2f
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x2864
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2080
movq %r14, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/junhe[P]libpatterndetector/pattern.cpp
// Function: PatternUnit::show[abi:cxx11]() const
string
PatternUnit::show() const
{
    ostringstream showstr;
    showstr << init << " ... ";
    showstr << PatternElem::show();
    return showstr.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x2140
movq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0x2100
leaq 0x2371(%rip), %rsi      # 0x514b
movq %rax, %rdi
callq 0x2110
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x29e4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x2080
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x2170
leaq 0x28(%rsp), %rdi
callq 0x2040
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2080
jmp 0x2e43
jmp 0x2e40
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/junhe[P]libpatterndetector/pattern.cpp
// Function: RequestPatternList::show[abi:cxx11]() const
const string
RequestPatternList::show() const
{
    vector<RequestPattern>::const_iterator it;
    vector<PatternUnit>::const_iterator it2;
    
    ostringstream oss;

    for ( it = list.begin() ;
          it != list.end() ;
          it++ )
    {
        oss << "--- offset ---" << endl;
        oss << it->offset.show();
        for ( it2 = it->length.chain.begin() ; 
              it2 != it->length.chain.end() ;
              it2++ )
        {
            oss << "--- length ---" << endl;
            oss << it2->show() << endl;
        }
    }
    return oss.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x2140
movq (%r14), %r12
leaq 0x10(%rsp), %rbp
leaq 0x19e0(%rip), %rbx      # 0x51dd
cmpq 0x8(%r14), %r12
je 0x3891
movq %r15, %rdi
leaq 0x19bd(%rip), %rsi      # 0x51ce
callq 0x2110
movq %rax, %rdi
callq 0x2090
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2da8
movq %r15, %rdi
movq %rbp, %rsi
callq 0x20f0
movq %rbp, %rdi
callq 0x2080
movq 0x38(%r12), %r13
cmpq 0x40(%r12), %r13
je 0x3888
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2110
movq %rax, %rdi
callq 0x2090
movq (%r13), %rax
movq %rbp, %rdi
movq %r13, %rsi
callq *(%rax)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x2090
movq %rbp, %rdi
callq 0x2080
addq $0x30, %r13
jmp 0x3841
addq $0x50, %r12
jmp 0x37fd
leaq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2170
leaq 0x30(%rsp), %rdi
callq 0x2040
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x38db
jmp 0x38db
jmp 0x38cc
jmp 0x38db
jmp 0x38db
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2080
jmp 0x38de
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/junhe[P]libpatterndetector/./pattern.h
// Function: PatternChain<PatternUnit>::isPopSafe(int)
bool
PatternChain<T>::isPopSafe( int t ) 
{
    typename vector<T>::reverse_iterator rit;
    
    int total = 0;
    rit = chain.rbegin();
    while ( rit != chain.rend()
            && total < t )
    {
        total += rit->size();
        rit++;
    }
    return total == t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r14
xorl %ebp, %ebp
cmpq %r15, %r14
je 0x3cb8
cmpl %ebx, %ebp
jge 0x3cb8
addq $-0x30, %r14
movq %r14, %rdi
callq 0x29c6
addl %eax, %ebp
jmp 0x3c9f
cmpl %ebx, %ebp
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/junhe[P]libpatterndetector/./pattern.h
// Function: PatternChain<PatternUnit>::popElem(int)
bool
PatternChain<T>::popElem ( int t )
{
    if ( !isPopSafe(t) ) {
        return false;
    }

    int total = 0; // the number of elem already popped out
    while ( !chain.empty() && total < t ) {
        total += top().size();
        chain.pop_back();
    }
    assert( total == t );

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x3c8c
testb %al, %al
je 0x3d4c
movb %al, 0x7(%rsp)
leaq 0x8(%r14), %r15
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
pushq $0x1
popq %rbp
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x3d43
cmpl %ebx, %r13d
jge 0x3d43
movq %r12, %rdi
movq %r14, %rsi
callq 0x3d7a
movq 0x28(%rsp), %rcx
movl %ebp, %eax
testq %rcx, %rcx
je 0x3d2e
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
shrq $0x3, %rax
imull %ecx, %eax
addl %eax, %r13d
movq %r12, %rdi
callq 0x2522
movq %r15, %rdi
callq 0x4ace
jmp 0x3cf7
cmpl %ebx, %r13d
movb 0x7(%rsp), %al
jne 0x3d5b
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x154c(%rip), %rdi      # 0x52ae
leaq 0x1550(%rip), %rsi      # 0x52b9
leaq 0x1555(%rip), %rcx      # 0x52c5
movl $0xeb, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/junhe[P]libpatterndetector/./pattern.h
// Function: PatChain<PatternUnit>::show[abi:cxx11]()
virtual string show()
        {
            typename vector<T>::const_iterator iter;
            ostringstream showstr;
            for ( iter = this->chain.begin();
                    iter != this->chain.end();
                    iter++ )
            {
                vector<off_t>::const_iterator off_iter;
                showstr << iter->init << "- (" ;
                for ( off_iter = (iter->seq).begin();
                        off_iter != (iter->seq).end();
                        off_iter++ )
                {
                    showstr << *off_iter << ", ";
                }
                showstr << ")^" << iter->cnt << endl;
            }
            return showstr.str(); 
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x2140
movq 0x8(%r14), %rbx
leaq 0x12ab(%rip), %r13      # 0x5260
leaq 0x12a1(%rip), %rbp      # 0x525d
cmpq 0x10(%r14), %rbx
je 0x4029
movq 0x28(%rbx), %rsi
movq %r15, %rdi
callq 0x2100
movq %rax, %rdi
leaq 0x1281(%rip), %rsi      # 0x5259
callq 0x2110
movq 0x8(%rbx), %r12
cmpq 0x10(%rbx), %r12
je 0x4004
movq (%r12), %rsi
movq %r15, %rdi
callq 0x2100
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2110
addq $0x8, %r12
jmp 0x3fe1
movq %r15, %rdi
movq %r13, %rsi
callq 0x2110
movq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x2090
addq $0x30, %rbx
jmp 0x3fbc
leaq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2170
leaq 0x10(%rsp), %rdi
callq 0x2040
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x405e
jmp 0x405e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/eschwabe[P]interview-practice/src/allsubsets.cpp
// Function: GetSubsets(std::set<int, std::less<int>, std::allocator<int>> const&, std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>>*)
void GetSubsets(const set<int>& s, vector<set<int>>* out) {
    if(s.size() == 0 || out == nullptr) {
        return;
    }
    for(auto v : s) {
        for(auto pset : vector<set<int>>{*out}) {
            set<int> tmp(pset);
            tmp.insert(v);
            out->push_back(tmp);
        }
        out->push_back(set<int>{v});
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
testq %rsi, %rsi
je 0x1392
cmpq $0x0, 0x28(%rdi)
je 0x1392
movq %rsi, %rbx
movq 0x18(%rdi), %rax
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
leaq 0x68(%rsp), %r13
leaq 0x38(%rsp), %rbp
leaq 0xc(%rsp), %r14
cmpq 0x10(%rsp), %rax
je 0x1392
movq %rax, 0x18(%rsp)
movl 0x20(%rax), %eax
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x151e
movq 0x20(%rsp), %r15
movq 0x28(%rsp), %r12
cmpq %r12, %r15
je 0x1345
movq %r13, %rdi
movq %r15, %rsi
callq 0x160c
movq %rbp, %rdi
movq %r13, %rsi
callq 0x160c
movq %rbp, %rdi
movq %r14, %rsi
callq 0x19a6
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x1578
movq %rbp, %rdi
callq 0x1850
movq %r13, %rdi
callq 0x1850
addq $0x30, %r15
jmp 0x12fe
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x15a4
movl 0xc(%rsp), %eax
movl %eax, 0x38(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
leaq 0xb(%rsp), %r8
callq 0x15c6
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1de4
movq %r13, %rdi
callq 0x1850
movq 0x18(%rsp), %rdi
callq 0x1100
jmp 0x12d0
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x13e3
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x1850
jmp 0x13e3
movq %rax, %rbx
jmp 0x13d9
movq %rax, %rbx
jmp 0x13cf
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1850
leaq 0x68(%rsp), %rdi
callq 0x1850
leaq 0x20(%rsp), %rdi
callq 0x15a4
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/eschwabe[P]interview-practice/src/allsubsets.cpp
// Function: main
int main()
{
    set<int> s{1,2,3,4};
    vector<set<int>> output;

    GetSubsets(s, &output);

    for(auto o : output) {
        for(auto v : o) {
            cout << v << " ";
        }
        cout << endl;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movaps 0xc0d(%rip), %xmm0      # 0x2010
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x68(%rsp), %rbx
pushq $0x4
popq %rdx
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rcx
callq 0x15c6
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x128c
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %r14
leaq 0x30(%rsp), %r13
movq 0x2b77(%rip), %r15      # 0x3fd8
leaq 0xbb8(%rip), %r12       # 0x2020
cmpq 0x28(%rsp), %rbx
je 0x14c4
movq %r13, %rbp
movq %r13, %rdi
movq %rbx, %rsi
callq 0x160c
movq 0x48(%rsp), %r13
cmpq %r14, %r13
je 0x14ab
movl 0x20(%r13), %esi
movq %r15, %rdi
callq 0x1140
movq %rax, %rdi
movq %r12, %rsi
callq 0x10c0
movq %r13, %rdi
callq 0x1100
movq %rax, %r13
jmp 0x1482
movq %r15, %rdi
callq 0x1070
movq %rbp, %r13
movq %rbp, %rdi
callq 0x1850
addq $0x30, %rbx
jmp 0x1468
leaq 0x10(%rsp), %rdi
callq 0x15a4
leaq 0x68(%rsp), %rdi
callq 0x1850
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14f0
jmp 0x14f5
movq %rax, %rbx
jmp 0x1502
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1850
leaq 0x10(%rsp), %rdi
callq 0x15a4
leaq 0x68(%rsp), %rdi
callq 0x1850
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/npaster[P]gmsh_tools/gmshElement.cpp
// Function: gmsh::Node::print() const
void
Node::print() const
{
   std::cout << "--------------- Node --------------" << std::endl;
   std::cout << "Index: " << m_index << std::endl;
   std::cout << "Reference: " << m_ref << std::endl;
   std::cout << "Coordinates: " << std::endl;
   std::cout << "[x, y, z] = [ " << m_coordinate[0] << " " << m_coordinate[1] << " "
             << m_coordinate[2] << " ];" << std::endl;
   std::cout << "--------------------------------------" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x11ae6(%rip), %rbx     # 0x13fd8
leaq 0xab0b(%rip), %rsi      # 0xd004
movq %rbx, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20f0
leaq 0xab18(%rip), %rsi      # 0xd028
movq %rbx, %rdi
callq 0x21c0
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20f0
leaq 0xaafd(%rip), %rsi      # 0xd030
movq %rbx, %rdi
callq 0x21c0
movq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20f0
leaq 0xaae6(%rip), %rsi      # 0xd03c
movq %rbx, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20f0
leaq 0xaadd(%rip), %rsi      # 0xd04a
movq %rbx, %rdi
callq 0x21c0
movsd (%r14), %xmm0
movq %rax, %rdi
callq 0x2250
leaq 0xb7c3(%rip), %r15      # 0xdd4c
movq %rax, %rdi
movq %r15, %rsi
callq 0x21c0
movsd 0x8(%r14), %xmm0
movq %rax, %rdi
callq 0x2250
movq %rax, %rdi
movq %r15, %rsi
callq 0x21c0
movsd 0x10(%r14), %xmm0
movq %rax, %rdi
callq 0x2250
leaq 0xaa97(%rip), %rsi      # 0xd059
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20f0
leaq 0xaa84(%rip), %rsi      # 0xd05d
movq %rbx, %rdi
callq 0x21c0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/npaster[P]gmsh_tools/gmshElement.cpp
// Function: gmsh::Element::print() const
void
Element::print() const
{
   std::cout << "--------------- Element --------------" << std::endl;
   std::cout << "Index: " << _index << std::endl;
   std::cout << "Type_elem: " << _type_elem << std::endl;
   std::cout << "Physical_entities: " << _physical_entities << std::endl;
   std::cout << "ElemTag: " << _elem_tag << std::endl;
   std::cout << "Number of Node: " << _nodes.size() << std::endl;

   for (size_t i = 0; i < _nodes.size(); i++) {
      std::cout << "Node " << i << " " << _nodes[i] << std::endl;
   }

   std::cout << "--------------------------------------" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x11884(%rip), %r14     # 0x13fd8
leaq 0xa929(%rip), %rsi      # 0xd084
movq %r14, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20f0
leaq 0xa8b6(%rip), %rsi      # 0xd028
movq %r14, %rdi
callq 0x21c0
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20f0
leaq 0xa916(%rip), %rsi      # 0xd0ab
movq %r14, %rdi
callq 0x21c0
movq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20f0
leaq 0xa8ff(%rip), %rsi      # 0xd0b7
movq %r14, %rdi
callq 0x21c0
movq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20f0
leaq 0xa8f0(%rip), %rsi      # 0xd0cb
movq %r14, %rdi
callq 0x21c0
movq 0x30(%rbx), %rsi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20f0
leaq 0xa8d7(%rip), %rsi      # 0xd0d5
movq %r14, %rdi
callq 0x21c0
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x3, %rsi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20f0
xorl %r15d, %r15d
leaq 0xa8bb(%rip), %r12      # 0xd0e6
leaq 0xb51a(%rip), %r13      # 0xdd4c
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
cmpq %rax, %r15
jae 0x287f
movq %r14, %rdi
movq %r12, %rsi
callq 0x21c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
movq %rax, %rdi
movq %r13, %rsi
callq 0x21c0
movq (%rbx), %rcx
movq (%rcx,%r15,8), %rsi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20f0
incq %r15
jmp 0x2832
movq 0x11752(%rip), %rdi     # 0x13fd8
leaq 0xa7d0(%rip), %rsi      # 0xd05d
callq 0x21c0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_cpp_makefile_star2_O2/npaster[P]gmsh_tools/gmshMesh.cpp
// Function: gmsh::Gmesh::readGmesh(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void
Gmesh::readGmesh(const std::string name_mesh)
{
   size_t      pos = name_mesh.find(".m");
   std::string ext = name_mesh.substr(pos);

   if (ext == ".mesh") {
      Gmesh::readGmesh_MEDITformat(name_mesh);
   } else if (ext == ".msh") {
      Gmesh::readGmesh_MSHformat(name_mesh);
   } else {
      std::cout << "Unknown file format" << std::endl;
      abort();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8ac2(%rip), %rsi      # 0xda12
movq %r14, %rdi
xorl %edx, %edx
callq 0x22d0
leaq -0x38(%rbp), %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x21e0
leaq 0x8a9f(%rip), %rsi      # 0xda15
movq %r15, %rdi
callq 0x8553
testb %al, %al
je 0x4f9e
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x21f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3adc
jmp 0x4fcc
leaq 0x8e91(%rip), %rsi      # 0xde36
leaq -0x38(%rbp), %rdi
callq 0x8553
testb %al, %al
je 0x4fe8
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x21f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x467e
movq %r15, %rdi
callq 0x20d0
leaq -0x38(%rbp), %rdi
callq 0x20d0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xefe9(%rip), %rdi      # 0x13fd8
leaq 0x8a25(%rip), %rsi      # 0xda1b
callq 0x21c0
movq %rax, %rdi
callq 0x20f0
callq 0x2140
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
jmp 0x5018
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x20d0
jmp 0x5022
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/npaster[P]gmsh_tools/gmshMesh.cpp
// Function: gmsh::Gmesh::writeGmesh(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long) const
void
Gmesh::writeGmesh(const std::string name_mesh, const size_t format) const
{
   if (format == 1) {
      Gmesh::writeGmesh_MEDITformat(name_mesh);
   } else if (format == 2) {
      Gmesh::writeGmesh_MSHformat(name_mesh);
   } else {
      std::cout << "Unknown file format" << std::endl;
      abort();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpq $0x2, %rdx
je 0x7063
cmpq $0x1, %rdx
jne 0x708b
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x21f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5034
jmp 0x707a
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x21f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5ce6
movq %rbx, %rdi
callq 0x20d0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0xcf46(%rip), %rdi      # 0x13fd8
leaq 0x6982(%rip), %rsi      # 0xda1b
callq 0x21c0
movq %rax, %rdi
callq 0x20f0
callq 0x2140
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x70bb
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/npaster[P]gmsh_tools/gmshMesh.cpp
// Function: gmsh::Gmesh::convertInDiscontinuousMesh1()
void
Gmesh::convertInDiscontinuousMesh1()
{
   const size_t      numberofNewNodes = 2 * _edges.size();
   std::vector<Node> oldNodes(_nodes);

   _nodes.clear();
   _nodes.reserve(numberofNewNodes);
   size_t indexCurrentNode = 1;

   for (size_t i = 0; i < _edges.size(); i++) {
      std::vector<size_t> indexnodes = (_edges.at(i)).getNodes();

      for (size_t j = 0; j < 2; j++) {
         Node tmpNode((oldNodes.at(indexnodes.at(j) - 1)));
         tmpNode.changeIndex(indexCurrentNode);
         (_edges.at(i)).changeNode(j, indexCurrentNode);
         _nodes.push_back(tmpNode);
         indexCurrentNode += 1;
      }
   }

   assert(indexCurrentNode - 1 == numberofNewNodes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
subq 0x38(%rdi), %rax
pushq $0x38
popq %rcx
cqto
idivq %rcx
movq %rax, %r14
addq %rax, %r14
leaq 0x8(%rdi), %rsi
leaq -0x78(%rbp), %rdi
movq %rsi, -0x30(%rbp)
callq 0x7d88
movq 0x8(%rbx), %rax
cmpq %rax, 0x10(%rbx)
je 0x745d
movq %rax, 0x10(%rbx)
movq -0x30(%rbp), %rdi
movq %r14, -0x40(%rbp)
movq %r14, %rsi
callq 0x85a0
movq %rbx, -0x48(%rbp)
leaq 0x38(%rbx), %rax
movq %rax, -0x38(%rbp)
pushq $0x1
popq %r12
xorl %r13d, %r13d
leaq -0xa0(%rbp), %rbx
movq -0x48(%rbp), %rcx
movq 0x40(%rcx), %rax
subq 0x38(%rcx), %rax
cqto
pushq $0x38
popq %rcx
idivq %rcx
cmpq %rax, %r13
jae 0x754b
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x8662
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x26e4
xorl %r14d, %r14d
leaq (%r12,%r14), %r15
cmpq $0x2, %r14
je 0x7537
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x869e
movq (%rax), %rsi
decq %rsi
leaq -0x78(%rbp), %rdi
callq 0x8680
movq 0x20(%rax), %rcx
movq %rcx, -0x80(%rbp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, -0x90(%rbp)
movaps %xmm0, -0xa0(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2620
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x8662
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2706
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x8354
incq %r14
jmp 0x74bf
leaq -0x60(%rbp), %rdi
callq 0x2e88
incq %r13
movq %r15, %r12
jmp 0x7487
decq %r12
cmpq -0x40(%rbp), %r12
jne 0x756c
leaq -0x78(%rbp), %rdi
callq 0x8722
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x664d(%rip), %rdi      # 0xdbc0
leaq 0x61aa(%rip), %rsi      # 0xd724
leaq 0x6668(%rip), %rcx      # 0xdbe9
movl $0x323, %edx            # imm = 0x323
callq 0x2150
jmp 0x758d
movq %rax, %rbx
jmp 0x759e
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2e88
leaq -0x78(%rbp), %rdi
callq 0x8722
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/npaster[P]gmsh_tools/gmshMesh.cpp
// Function: gmsh::Gmesh::convertInDiscontinuousMesh()
void
Gmesh::convertInDiscontinuousMesh()
{
   if (_dim_topology == 1) {
      convertInDiscontinuousMesh1();
   } else if (_dim_topology == 2) {
      convertInDiscontinuousMesh2();
   } else if (_dim_topology == 3) {
      convertInDiscontinuousMesh3();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
cmpq $0x3, %rax
je 0x7cd3
cmpq $0x2, %rax
je 0x7ccd
cmpq $0x1, %rax
jne 0x7cd9
popq %rbp
jmp 0x7414
popq %rbp
jmp 0x75b0
popq %rbp
jmp 0x7824
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/npaster[P]gmsh_tools/gmshData.cpp
// Function: gmsh::NodeData::saveNodeData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, gmsh::Gmesh const&)
void
NodeData::saveNodeData(const std::string name_mesh, const Gmesh& mesh)
{
   Gmesh meshtmp(mesh);

   if (m_subdatas.size() > 0) {
      size_t indnode = mesh.getNumberofNodes();
      for (size_t i = 0; i < m_subdatas.size(); i++) {
         m_subdatas[i].changeIndex(indnode + i + 1);
         meshtmp.addNode(m_subdatas[i].getNode());
         Vertice vert(indnode + i + 1, indnode + i + 1, 1, 1);
         meshtmp.addVertice(vert);
      }
   }
   meshtmp.writeGmesh(name_mesh, 2);
   writeNodeData(name_mesh);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rdx, %r14
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
leaq -0x198(%rbp), %rdi
movq %rdx, %rsi
callq 0xb992
movq 0x50(%rbx), %rax
movq %rbx, -0x30(%rbp)
cmpq 0x48(%rbx), %rax
je 0xae45
movq %r14, %rdi
callq 0x3808
movq %rax, %rcx
incq %rcx
xorl %r12d, %r12d
leaq -0xb0(%rbp), %r13
xorl %r14d, %r14d
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rdi
movq 0x50(%rax), %rax
subq %rdi, %rax
cqto
pushq $0x48
popq %rsi
idivq %rsi
cmpq %rax, %r14
jae 0xae45
addq %r12, %rdi
movq %rcx, %rbx
leaq (%rcx,%r14), %r15
movq %r15, %rsi
callq 0xa5f2
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x40(%rax,%r12), %rcx
movq %rcx, -0x90(%rbp)
movups 0x20(%rax,%r12), %xmm0
movups 0x30(%rax,%r12), %xmm1
movaps %xmm1, -0xa0(%rbp)
movaps %xmm0, -0xb0(%rbp)
leaq -0x198(%rbp), %rdi
movq %r13, %rsi
callq 0x72f6
movq %r13, %rdi
movq %r15, %rsi
movq %r15, %rdx
pushq $0x1
popq %rcx
movq %rcx, %r8
callq 0x28c4
leaq -0x198(%rbp), %rdi
movq %r13, %rsi
callq 0x7304
movq %r13, %rdi
callq 0x2e88
incq %r14
addq $0x48, %r12
movq %rbx, %rcx
jmp 0xad9c
leaq -0x78(%rbp), %rdi
movq -0x38(%rbp), %r14
movq %r14, %rsi
callq 0x21f0
leaq -0x198(%rbp), %rdi
leaq -0x78(%rbp), %rsi
pushq $0x2
popq %rdx
callq 0x7030
leaq -0x78(%rbp), %rdi
callq 0x20d0
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x21f0
leaq -0x58(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0xa90e
leaq -0x58(%rbp), %rdi
callq 0x20d0
leaq -0x198(%rbp), %rdi
callq 0xbaea
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xaed0
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
jmp 0xaec3
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x20d0
jmp 0xaee4
jmp 0xaed0
jmp 0xaed0
jmp 0xaed0
movq %rax, %rbx
jmp 0xaee4
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x2e88
leaq -0x198(%rbp), %rdi
callq 0xbaea
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/skyleaworlder[P]AES/src/AddRoundKey.cpp
// Function: AddRoundKey(std::vector<std::bitset<8ul>, std::allocator<std::bitset<8ul>>>, std::vector<std::bitset<8ul>, std::allocator<std::bitset<8ul>>>)
vector<byte> AddRoundKey(
    vector<byte> input,
    vector<byte> round_key
) {
    assert(input.size() == 16 && round_key.size() == 16);
    vector<byte> ret;
    for (size_t index = 0; index < input.size(); ++index)
        ret.push_back(input[index] ^ round_key[index]);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x80, %rdx
jne 0x24af
movq 0x8(%r14), %rdx
subq (%r14), %rdx
cmpq $0x80, %rdx
jne 0x24af
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r13d, %r13d
leaq -0x30(%rbp), %r12
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0x249d
movq (%r14), %rcx
movq (%rcx,%r13,8), %rcx
xorq (%rax,%r13,8), %rcx
movq %rcx, -0x30(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x252c
incq %r13
movq (%r15), %rax
movq 0x8(%r15), %rcx
jmp 0x246b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b4e(%rip), %rdi      # 0x4004
leaq 0x1b74(%rip), %rsi      # 0x4031
leaq 0x1b81(%rip), %rcx      # 0x4045
pushq $0x7
popq %rdx
callq 0x20d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x24ee
movq %r14, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/skyleaworlder[P]AES/src/KeyExpan.cpp
// Function: Key_Expansion(std::vector<std::bitset<8ul>, std::allocator<std::bitset<8ul>>>, unsigned long)
vector<vector<byte>> Key_Expansion(
    vector<byte> input,
    size_t total_turn
) {
    vector<vector<byte>> ret { input };
    for (size_t index = 0; index < total_turn; ++index)
        ret.push_back(next_key(
            ret[index], index
        ));
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, %rbx
leaq -0x50(%rbp), %rdi
callq 0x296a
leaq -0x50(%rbp), %rsi
pushq $0x1
popq %rdx
leaq -0x29(%rbp), %rcx
movq %rbx, %rdi
callq 0x29ba
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x24ee
xorl %r14d, %r14d
leaq -0x68(%rbp), %r12
xorl %r13d, %r13d
cmpq %r13, -0x38(%rbp)
je 0x2754
movq (%rbx), %rsi
addq %r14, %rsi
movq %r12, %rdi
callq 0x296a
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x27a8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2c52
movq %r15, %rdi
callq 0x24ee
movq %r12, %rdi
callq 0x24ee
incq %r13
addq $0x18, %r14
jmp 0x270e
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x24ee
jmp 0x27a0
movq %rax, %r14
jmp 0x27a0
movq %rax, %r14
jmp 0x2798
movq %rax, %r14
jmp 0x278f
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x24ee
leaq -0x68(%rbp), %rdi
callq 0x24ee
movq %rbx, %rdi
callq 0x29f4
movq %r14, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/skyleaworlder[P]AES/src/Misc.cpp
// Function: byte_to_vector(std::bitset<128ul>)
vector<byte> byte_to_vector(std::bitset<128> input) {
    /* cos tmp is reverse */
    vector<byte> ret, tmp;
    for (size_t index = 0; index < 128 / 8; ++index) {
        tmp.push_back(std::bitset<8> {
            (input & std::bitset<128> { 0xFF }).to_ulong()
        });
        input >>= 8;
    }
    while (tmp.size()) {
        ret.push_back(tmp.back());
        tmp.pop_back();
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq -0x78(%rbp), %r14
movq %rsi, (%r14)
movq %rdx, 0x8(%r14)
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq -0x40(%rbp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
pushq $0x10
popq %r13
leaq -0x48(%rbp), %r12
pushq $0x8
popq %r15
subq $0x1, %r13
jb 0x301e
movq $0xff, -0x58(%rbp)
andq $0x0, -0x50(%rbp)
movq %r14, %rdi
leaq -0x58(%rbp), %rsi
callq 0x324b
movq %rax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3290
movzbl %al, %eax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0x252c
movq %r14, %rdi
movq %r15, %rsi
callq 0x32ac
jmp 0x2fce
movq -0x38(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x3042
addq $-0x8, %rsi
movq %rbx, %rdi
callq 0x2a56
movq -0x38(%rbp), %rsi
addq $-0x8, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x3022
leaq -0x40(%rbp), %rdi
callq 0x24ee
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x305f
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x24ee
movq %rbx, %rdi
callq 0x24ee
movq %r14, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/skyleaworlder[P]AES/src/Misc.cpp
// Function: vector_to_2_vector(std::vector<std::bitset<8ul>, std::allocator<std::bitset<8ul>>>)
vector<vector<byte>> vector_to_2_vector(vector<byte> input) {
    assert(input.size() == 16);
    return vector<vector<byte>> {
        vector<byte> { input[0], input[1], input[2], input[3] },
        vector<byte> { input[4], input[5], input[6], input[7] },
        vector<byte> { input[8], input[9], input[10], input[11] },
        vector<byte> { input[12], input[13], input[14], input[15] },
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
cmpq $0x80, %rcx
jne 0x31eb
movq %rsi, %r12
movq %rdi, %rbx
movq (%rax), %rcx
leaq -0x110(%rbp), %rsi
movq %rcx, (%rsi)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsi)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsi)
leaq -0x90(%rbp), %r14
pushq $0x4
popq %r13
leaq -0x2d(%rbp), %rcx
movq %r14, %rdi
movq %r13, %rdx
callq 0x2a20
leaq -0x78(%rbp), %r15
movq (%r12), %rax
movq 0x20(%rax), %rcx
leaq -0xf0(%rbp), %rsi
movq %rcx, (%rsi)
movq 0x28(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x30(%rax), %rcx
movq %rcx, 0x10(%rsi)
movq 0x38(%rax), %rax
movq %rax, 0x18(%rsi)
leaq -0x2c(%rbp), %rcx
movq %r15, %rdi
movq %r13, %rdx
callq 0x2a20
leaq -0x60(%rbp), %r15
movq (%r12), %rax
movq 0x40(%rax), %rcx
leaq -0xd0(%rbp), %rsi
movq %rcx, (%rsi)
movq 0x48(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x50(%rax), %rcx
movq %rcx, 0x10(%rsi)
movq 0x58(%rax), %rax
movq %rax, 0x18(%rsi)
pushq $0x4
popq %rdx
leaq -0x2b(%rbp), %rcx
movq %r15, %rdi
callq 0x2a20
leaq -0x48(%rbp), %r15
movq (%r12), %rax
movq 0x60(%rax), %rcx
leaq -0xb0(%rbp), %rsi
movq %rcx, (%rsi)
movq 0x68(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x70(%rax), %rcx
movq %rcx, 0x10(%rsi)
movq 0x78(%rax), %rax
movq %rax, 0x18(%rsi)
pushq $0x4
popq %rdx
leaq -0x2a(%rbp), %rcx
movq %r15, %rdi
callq 0x2a20
leaq -0x90(%rbp), %rsi
pushq $0x4
popq %rdx
leaq -0x29(%rbp), %rcx
movq %rbx, %rdi
callq 0x29ba
pushq $0x48
popq %r14
leaq (%r14,%rbp), %rdi
addq $-0x90, %rdi
callq 0x24ee
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x31bc
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf28(%rip), %rdi       # 0x411a
leaq 0xf34(%rip), %rsi       # 0x412d
leaq 0xf3a(%rip), %rcx       # 0x413a
pushq $0x14
popq %rdx
callq 0x20d0
movq %rax, %rbx
pushq $0x48
popq %r14
leaq (%r14,%rbp), %rdi
addq $-0x90, %rdi
callq 0x24ee
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x320f
jmp 0x3243
jmp 0x322f
jmp 0x322f
movq %rax, %rbx
addq $-0x18, %r15
movq %r15, %rdi
callq 0x24ee
cmpq %r14, %r15
jne 0x3232
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/skyleaworlder[P]AES/src/MixColumns.cpp
// Function: MixColumns(std::vector<std::bitset<8ul>, std::allocator<std::bitset<8ul>>>)
vector<byte> MixColumns(
    vector<byte> input
) {
    vector<byte> ret;
    vector<vector<byte>> total { vector_to_2_vector(input) };
    for (vector<byte> s : total) {
        byte x0 { s[0] }, x1 { s[1] }, x2 { s[2] }, x3 { s[3] };
        s[0] = x1 ^ x2 ^ x3;    s[1] = x0 ^ x2 ^ x3;
        s[2] = x0 ^ x1 ^ x3;    s[3] = x0 ^ x1 ^ x2;

        x0 = FieldMult(x0); x1 = FieldMult(x1);
        x2 = FieldMult(x2); x3 = FieldMult(x3);

        s[0] = s[0] ^ x0 ^ x1;  s[1] = s[1] ^ x1 ^ x2;
        s[2] = s[2] ^ x2 ^ x3;  s[3] = s[3] ^ x3 ^ x0;

        for (byte s_i : s)
            ret.push_back(s_i);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x88(%rbp), %rdi
callq 0x296a
leaq -0x70(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x307b
leaq -0x88(%rbp), %rdi
callq 0x24ee
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x58(%rbp), %r15
leaq -0x40(%rbp), %r12
cmpq -0x30(%rbp), %rsi
je 0x34dd
movq %r15, %r14
movq %r15, %rdi
movq %rsi, -0x38(%rbp)
callq 0x296a
movq -0x58(%rbp), %rax
movq (%rax), %r8
movq 0x8(%rax), %r10
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rcx
movq %rcx, %r9
xorq %rsi, %r9
movq %r9, %rdx
xorq %r10, %rdx
movq %rdx, (%rax)
xorq %r8, %r9
movq %r10, %rdx
xorq %r8, %rdx
movq %rcx, %rdi
xorq %rdx, %rdi
xorq %rsi, %rdx
leal (%r8,%r8), %r11d
movl $0xff, %r15d
andl %r15d, %r11d
movq %r11, %rax
xorq $0x1b, %rax
testb %r8b, %r8b
cmovnsq %r11, %rax
leal (%r10,%r10), %r11d
andl %r15d, %r11d
movq %r11, %r8
xorq $0x1b, %r8
testb %r10b, %r10b
movq -0x58(%rbp), %r10
cmovnsq %r11, %r8
movq %r9, 0x8(%r10)
leal (%rsi,%rsi), %r11d
andl %r15d, %r11d
movq %r11, %r9
xorq $0x1b, %r9
testb %sil, %sil
cmovnsq %r11, %r9
movq %rdi, 0x10(%r10)
leal (%rcx,%rcx), %esi
andl %r15d, %esi
movq %rsi, %rdi
xorq $0x1b, %rdi
testb %cl, %cl
cmovnsq %rsi, %rdi
movq %rdx, 0x18(%r10)
movq (%r10), %rcx
xorq %rax, %rcx
xorq %r8, %rcx
movq %rcx, (%r10)
movq -0x58(%rbp), %r13
xorq 0x8(%r13), %r8
xorq %r9, %r8
movq %r8, 0x8(%r13)
xorq 0x10(%r13), %r9
xorq %rdi, %r9
movq %r9, 0x10(%r13)
xorq 0x18(%r13), %rax
xorq %rdi, %rax
movq %rax, 0x18(%r13)
movq -0x50(%rbp), %r15
cmpq %r15, %r13
je 0x34c5
movq (%r13), %rax
movq %rax, -0x40(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2a56
addq $0x8, %r13
jmp 0x34a7
movq %r14, %r15
movq %r14, %rdi
callq 0x24ee
movq -0x38(%rbp), %rsi
addq $0x18, %rsi
jmp 0x33bd
leaq -0x70(%rbp), %rdi
callq 0x29f4
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x88(%rbp), %rdi
callq 0x24ee
jmp 0x3528
movq %rax, %r14
jmp 0x3528
movq %rax, %r14
jmp 0x351f
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x24ee
leaq -0x70(%rbp), %rdi
callq 0x29f4
movq %rbx, %rdi
callq 0x24ee
movq %r14, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/skyleaworlder[P]AES/src/SubBytes.cpp
// Function: SubBytes(std::vector<std::bitset<8ul>, std::allocator<std::bitset<8ul>>>)
vector<byte> SubBytes(
    vector<byte> input
) {
    assert(input.size() == 16);
    vector<byte> ret;
    for (byte elem : input) {
        size_t col_index = (elem & byte(0x0F)).to_ulong();
        size_t row_index = (elem & byte(0xF0)).to_ulong() >> 4;
        ret.push_back(s_box[row_index * 16 + col_index]);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %r15
movq %r15, %rax
subq %r14, %rax
cmpq $0x80, %rax
jne 0x3647
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x3b1b(%rip), %r12      # 0x7138
cmpq %r15, %r14
je 0x363b
movzbl (%r14), %esi
shll $0x3, %esi
addq (%r12), %rsi
movq %rbx, %rdi
callq 0x2a56
addq $0x8, %r14
jmp 0x361d
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xacc(%rip), %rdi       # 0x411a
leaq 0xb38(%rip), %rsi       # 0x418d
leaq 0xb42(%rip), %rcx       # 0x419e
pushq $0x6
popq %rdx
callq 0x20d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x24ee
movq %r14, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/skyleaworlder[P]AES/src/main.cpp
// Function: main
int main() {
    std::bitset<128> input(std::string("110010010000111111011010101000100010000101101000110000100011010011000100110001100110001010001011100000001101110000011100110100"));
    std::bitset<128> key(std::string("101011011111100001010100010110001010001010111011010010101001101010101111110111000101011000100000001001110011110100111100111100"));
    vector<byte> res { aes(input, key, 10) };
    for (byte elem : res)
        std::cout << elem << " ";
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x109d(%rip), %rsi      # 0x4b6e
leaq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x3bd8
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x3c14
leaq -0x50(%rbp), %rdi
callq 0x2080
leaq 0x10f0(%rip), %rsi      # 0x4bed
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x3bd8
leaq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x3c14
leaq -0x50(%rbp), %rdi
callq 0x2080
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %r8
leaq -0x50(%rbp), %rbx
pushq $0xa
popq %r9
movq %rbx, %rdi
callq 0x3684
movq (%rbx), %r12
movq 0x8(%rbx), %r13
movq 0x3488(%rip), %rbx      # 0x6fd8
leaq -0x30(%rbp), %r14
leaq 0x1111(%rip), %r15      # 0x4c6c
cmpq %r13, %r12
je 0x3b84
movq (%r12), %rax
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c55
movq %rax, %rdi
movq %r15, %rsi
callq 0x2130
addq $0x8, %r12
jmp 0x3b5b
movq 0x344d(%rip), %rdi      # 0x6fd8
callq 0x2090
leaq -0x50(%rbp), %rdi
callq 0x24ee
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3bc3
jmp 0x3bb0
jmp 0x3bbe
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2080
jmp 0x3bcf
movq %rax, %rbx
jmp 0x3bcf
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x24ee
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/porzell[P]PTest/examples/my_first_test.cpp
// Function: MyFirstTest5()
P_TEST(MyFirstTest) {
	std::string testString;

	testString += "hello";
	testString += ' ';
	testString += "world!";

	P_ASSERT(testString == "hello world!");
	P_EXPECT(testString == "goodbye world!");
	
	P_ASSERT(2 + 2 != 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x170, %rsp            # imm = 0x170
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x1d8a(%rip), %rsi      # 0x4166
leaq -0x30(%rbp), %rdi
callq 0x2200
leaq -0x30(%rbp), %rdi
pushq $0x20
popq %rsi
callq 0x2120
leaq 0x1d7a(%rip), %rsi      # 0x4172
leaq -0x30(%rbp), %rdi
callq 0x2200
leaq 0x1d64(%rip), %rsi      # 0x416c
leaq -0x30(%rbp), %rdi
callq 0x371e
movl %eax, %ebx
callq 0x2548
movq %rax, %r14
movzbl %bl, %esi
leaq 0x1d54(%rip), %rdx      # 0x4179
leaq 0x1d68(%rip), %r8       # 0x4194
leaq -0x180(%rbp), %rdi
pushq $0xc
popq %rcx
xorl %r9d, %r9d
callq 0x37de
leaq -0x180(%rbp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x372e
leaq -0x180(%rbp), %rdi
callq 0x2a20
testb %bl, %bl
je 0x24f2
callq 0x2548
movq %rax, %rbx
leaq 0x1d07(%rip), %rdx      # 0x4179
leaq 0x1d38(%rip), %r8       # 0x41b1
leaq -0x110(%rbp), %rdi
pushq $0xd
popq %rcx
xorl %esi, %esi
xorl %r9d, %r9d
callq 0x37de
leaq -0x110(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x372e
leaq -0x110(%rbp), %rdi
callq 0x2a20
callq 0x2548
movq %rax, %rbx
leaq 0x1cbf(%rip), %rdx      # 0x4179
leaq 0x1d0f(%rip), %r8       # 0x41d0
leaq -0xa0(%rbp), %rdi
pushq $0xf
popq %rcx
xorl %esi, %esi
xorl %r9d, %r9d
callq 0x37de
leaq -0xa0(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x372e
leaq -0xa0(%rbp), %rdi
callq 0x2a20
leaq -0x30(%rbp), %rdi
callq 0x20c0
addq $0x170, %rsp            # imm = 0x170
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
jmp 0x252b
jmp 0x2534
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
jmp 0x252b
movq %rax, %rbx
leaq -0x180(%rbp), %rdi
callq 0x2a20
jmp 0x2537
jmp 0x2534
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::traversalPrint(Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
void AVLTree<T>::traversalPrint(Node<T>* n) {
	if(root != 0) {
		traversalPrint(n->getLeftChild());
		std::cout << n->getValue() << std::endl;
		traversalPrint(n->getRightChild());
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpq $0x0, (%rdi)
je 0x4e6c
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x66b4
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4e04
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x668e
movq 0x8197(%rip), %rdi      # 0xcfd8
movq %r15, %rsi
callq 0x2130
movq %rax, %rdi
callq 0x20b0
movq %rsp, %rdi
callq 0x20a0
movq %r14, %rdi
callq 0x66c0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4e04
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2210
nop