LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/junhe[P]libpatterndetector/pattern.cpp
// Function: PatternUtil::searchNeighbor(std::vector<long, std::allocator<long>> const&, __gnu_cxx::__normal_iterator<long const*, std::vector<long, std::allocator<long>>>)
Tuple 
PatternUtil::searchNeighbor( vector<off_t> const &seq,
        vector<off_t>::const_iterator p_lookahead_win ) 
{
    vector<off_t>::const_iterator i;     
    int j;
    //cout << "------------------- I am in searchNeighbor() " << endl;

    //i goes left util the begin or reaching window size
    i = p_lookahead_win;
    int remain = seq.end() - p_lookahead_win;
    while ( i != seq.begin() 
            && (p_lookahead_win - i) < win_size
            && (p_lookahead_win - i) < remain ) {
        i--;
    }
    //termination: i == seq.begin() or distance == win_size

    /*
    //print out search buffer and lookahead buffer
    //cout << "search buf: " ;
    vector<off_t>::const_iterator k;
    for ( k = i ; k != p_lookahead_win ; k++ ) {
    cout << *k << " ";
    }
    cout << endl;

    cout << "lookahead buf: " ;
    vector<off_t>::const_iterator p;
    p = p_lookahead_win;
    for ( p = p_lookahead_win ; 
    p != seq.end() && p - p_lookahead_win < win_size ; 
    p++ ) {
    cout << *p << " ";
    }
    cout << endl;
    */

    //i points to a element in search buffer where matching starts
    //j is the iterator from the start to the end of search buffer to compare
    //smarter algorithm can be used better time complexity, like KMP.
    for ( ; i != p_lookahead_win ; i++ ) {
        int search_length = p_lookahead_win - i;
        for ( j = 0 ; j < search_length ; j++ ) {
            if ( *(i+j) != *(p_lookahead_win + j) ) {
                break;
            }
        }
        if ( j == search_length ) {
            //found a repeating neighbor
            return Tuple(search_length, search_length, 
                    *(p_lookahead_win + search_length));
        }
    }

    //Cannot find a repeating neighbor
    return Tuple(0, 0, *(p_lookahead_win));
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rsi, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq $0x6, %rcx
movl $0x6, %edx
cmovlq %rcx, %rdx
cmpq %rsi, %rax
je 0x41c6
xorl %edi, %edi
movq %rsi, %rcx
movq %rdi, %r8
sarq $0x3, %r8
cmpq %rdx, %r8
jge 0x4179
addq $-0x8, %rcx
addq $0x8, %rdi
cmpq %rax, %rcx
jne 0x415e
jmp 0x417e
testq %rdi, %rdi
je 0x41c6
xorl %eax, %eax
movq %rsi, %rdi
subq %rcx, %rdi
movq %rdi, %rdx
shrq $0x3, %rdx
movl $0x0, %r8d
testl %edx, %edx
jle 0x41b6
movl %edx, %r9d
andl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
xorl %r8d, %r8d
movq (%rcx,%r8,8), %r10
cmpq (%rsi,%r8,8), %r10
jne 0x41b6
incq %r8
cmpq %r9, %r8
jb 0x41a4
cmpl %edx, %r8d
je 0x41ca
addq $0x8, %rcx
cmpq %rsi, %rcx
jne 0x4180
jmp 0x41e1
xorl %eax, %eax
jmp 0x41e1
shlq $0x1d, %rdi
sarq $0x1d, %rdi
addq %rdi, %rsi
movl %edx, %eax
shlq $0x20, %rdx
orq %rax, %rdx
movq %rdx, %rax
movq (%rsi), %rdx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rdi, 0x20(%rsp)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x2160
movq (%rbx), %r12
movq %rbx, 0x28(%rsp)
cmpq 0x8(%rbx), %r12
je 0x4363
movq %rsp, %rbp
leaq 0x1fb5(%rip), %rbx      # 0x61dd
movl $0xe, %edx
movq %r15, %rdi
leaq 0x1f97(%rip), %rsi      # 0x61ce
callq 0x2150
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq %rbp, %rdi
movq %r12, %rsi
callq 0x3180
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x2150
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x429c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2140
movq 0x38(%r12), %r13
cmpq 0x40(%r12), %r13
je 0x4350
movl $0xe, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2150
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq (%r13), %rax
movq %rbp, %rdi
movq %r13, %rsi
callq *(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x2150
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x4347
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2140
addq $0x30, %r13
jmp 0x42a1
addq $0x50, %r12
movq 0x28(%rsp), %rax
cmpq 0x8(%rax), %r12
jne 0x4228
leaq 0x38(%rsp), %rsi
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x2190
movq 0x4c54(%rip), %rsi      # 0x8fd0
leaq 0x30(%rsp), %rdi
callq 0x20a0
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x43d2
jmp 0x43d2
jmp 0x43b2
jmp 0x43d2
jmp 0x43d2
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x43d5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2140
jmp 0x43d5
movq %rax, %rbx
movq 0x4bf4(%rip), %rsi      # 0x8fd0
leaq 0x30(%rsp), %rdi
callq 0x20a0
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
cmpq %rax, %rcx
sete %dil
testl %esi, %esi
setle %r8b
xorl %edx, %edx
orb %dil, %r8b
jne 0x48d5
addq $-0x30, %rcx
xorl %edx, %edx
movq 0x20(%rcx), %rdi
testq %rdi, %rdi
je 0x48c1
movq 0x10(%rcx), %r8
subq 0x8(%rcx), %r8
shrq $0x3, %r8
imull %r8d, %edi
jmp 0x48c6
movl $0x1, %edi
addl %edi, %edx
cmpq %rax, %rcx
je 0x48d5
addq $-0x30, %rcx
cmpl %esi, %edx
jl 0x48a6
cmpl %esi, %edx
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4884
testb %al, %al
je 0x49b1
movb %al, 0x7(%rsp)
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
sete %al
testl %ebx, %ebx
setle %cl
xorl %r12d, %r12d
orb %al, %cl
jne 0x49a8
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
leaq 0x440e(%rip), %r13      # 0x8d38
movq %r15, %rdi
movq %r14, %rsi
callq 0x49e0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rbp
testq %rbp, %rbp
je 0x4955
movq 0x18(%rsp), %rax
subq %rdi, %rax
shrq $0x3, %rax
imull %eax, %ebp
jmp 0x495a
movl $0x1, %ebp
movq %r13, 0x8(%rsp)
testq %rdi, %rdi
je 0x4971
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x10(%r14), %rax
leaq -0x30(%rax), %rcx
movq %rcx, 0x10(%r14)
movq %r13, -0x30(%rax)
movq -0x28(%rax), %rdi
testq %rdi, %rdi
je 0x4996
movq -0x18(%rax), %rsi
subq %rdi, %rsi
callq 0x2140
addl %ebp, %r12d
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x49a8
cmpl %ebx, %r12d
jl 0x492a
cmpl %ebx, %r12d
movb 0x7(%rsp), %al
jne 0x49c0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18e7(%rip), %rdi      # 0x62ae
leaq 0x18eb(%rip), %rsi      # 0x62b9
leaq 0x18f0(%rip), %rcx      # 0x62c5
movl $0xeb, %edx
callq 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rdi
callq 0x2160
movq 0x8(%r14), %r12
cmpq 0x10(%r14), %r12
je 0x4c2d
leaq 0x10(%rsp), %r15
leaq 0x16dd(%rip), %r13      # 0x6260
leaq 0x16d3(%rip), %rbp      # 0x625d
movq 0x28(%r12), %rsi
movq %r15, %rdi
callq 0x2110
movl $0x3, %edx
movq %rax, %rdi
leaq 0x16b3(%rip), %rsi      # 0x6259
callq 0x2150
movq 0x8(%r12), %rbx
cmpq 0x10(%r12), %rbx
je 0x4bd8
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x2110
movl $0x2, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2150
addq $0x8, %rbx
jmp 0x4bb0
movl $0x2, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x2150
movq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x2110
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
addq $0x30, %r12
cmpq 0x10(%r14), %r12
jne 0x4b8a
leaq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2190
movq 0x438a(%rip), %rsi      # 0x8fd0
leaq 0x10(%rsp), %rdi
callq 0x20a0
leaq 0x80(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c76
jmp 0x4c76
movq %rax, %rbx
movq 0x4350(%rip), %rsi      # 0x8fd0
leaq 0x10(%rsp), %rdi
callq 0x20a0
leaq 0x80(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13db
cmpq $0x0, 0x28(%rdi)
je 0x13db
movq 0x18(%rdi), %rax
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
cmpq %rdi, %rax
je 0x13db
movq %rsi, %rbx
leaq 0x20(%rsp), %r15
leaq 0x68(%rsp), %r13
leaq 0x38(%rsp), %rbp
leaq 0xc(%rsp), %r14
movq %rax, 0x18(%rsp)
movl 0x20(%rax), %eax
movl %eax, 0xc(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x159e
movq 0x20(%rsp), %r12
movq 0x28(%rsp), %r15
cmpq %r15, %r12
je 0x1386
movq %r13, %rdi
movq %r12, %rsi
callq 0x1730
movq %rbp, %rdi
movq %r13, %rsi
callq 0x1730
movq %rbp, %rdi
movq %r14, %rsi
callq 0x19d0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x163a
movq %rbp, %rdi
callq 0x1910
movq %r13, %rdi
callq 0x1910
addq $0x30, %r12
jmp 0x133f
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x1666
movl 0xc(%rsp), %eax
movl %eax, 0x38(%rsp)
movl $0x1, %edx
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rcx
leaq 0xb(%rsp), %r8
callq 0x16ae
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1dde
movq %r13, %rdi
callq 0x1910
movq 0x18(%rsp), %rdi
callq 0x1120
cmpq 0x10(%rsp), %rax
jne 0x131e
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x1910
jmp 0x142c
movq %rax, %rbx
jmp 0x142c
movq %rax, %rbx
jmp 0x1422
movq %rax, %rbx
jmp 0x1418
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1910
leaq 0x68(%rsp), %rdi
callq 0x1910
leaq 0x20(%rsp), %rdi
callq 0x1666
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbc4(%rip), %xmm0      # 0x2010
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x68(%rsp), %rbx
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %r8
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x16ae
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x12cc
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq %rax, %rbx
je 0x1544
leaq 0x38(%rsp), %r14
leaq 0x30(%rsp), %r13
movq 0x2b20(%rip), %r15      # 0x3fd8
leaq 0xb71(%rip), %r12       # 0x2030
movq %r13, %rbp
movq %r13, %rdi
movq %rbx, %rsi
callq 0x1730
movq 0x48(%rsp), %r13
cmpq %r14, %r13
je 0x1503
movl 0x20(%r13), %esi
movq %r15, %rdi
callq 0x1160
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x1110
movq %r13, %rdi
callq 0x1120
movq %rax, %r13
cmpq %r14, %rax
jne 0x14d7
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movq %rbp, %r13
movq %rbp, %rdi
callq 0x1910
addq $0x30, %rbx
cmpq 0x28(%rsp), %rbx
jne 0x14bf
leaq 0x10(%rsp), %rdi
callq 0x1666
leaq 0x68(%rsp), %rdi
callq 0x1910
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x156e
movq %rax, %rbx
jmp 0x1582
jmp 0x1575
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1910
leaq 0x10(%rsp), %rdi
callq 0x1666
leaq 0x68(%rsp), %rdi
callq 0x1910
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O3/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 0xba36(%rip), %rsi      # 0x11a12
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x22e0
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x2220
leaq 0xba0a(%rip), %rsi      # 0x11a15
movq %r15, %rdi
callq 0x2090
testl %eax, %eax
je 0x6058
leaq 0xbe48(%rip), %rsi      # 0x11e66
leaq -0x78(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x60aa
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0xb17c
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x5428
movq -0x38(%rbp), %rdi
jmp 0x6083
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0xb17c
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x43e0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x608d
callq 0x21e0
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x609f
callq 0x21e0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10f27(%rip), %rdi     # 0x16fd8
leaq 0xb963(%rip), %rsi      # 0x11a1b
movl $0x13, %edx
callq 0x2230
movq 0x10f0f(%rip), %rdi     # 0x16fd8
callq 0x20f0
callq 0x2140
movq %rax, %rbx
movq -0x58(%rbp), %rdi
jmp 0x60e3
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x60f2
callq 0x21e0
jmp 0x60f2
movq %rax, %rbx
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6104
callq 0x21e0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpq $0x2, %rdx
je 0x91ca
cmpq $0x1, %rdx
jne 0x920f
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xb17c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x610c
movq -0x58(%rbp), %rdi
jmp 0x91fa
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xb17c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x75da
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x9204
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xddc2(%rip), %rdi      # 0x16fd8
leaq 0x87fe(%rip), %rsi      # 0x11a1b
callq 0x2200
movq %rax, %rdi
callq 0x20f0
callq 0x2140
movq %rax, %rbx
movq -0x58(%rbp), %rdi
jmp 0x923f
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x9249
callq 0x21e0
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa3a1
cmpq $0x2, %rax
je 0xa39b
cmpq $0x1, %rax
jne 0xa3a7
popq %rbp
jmp 0x97cc
popq %rbp
jmp 0x9a30
popq %rbp
jmp 0x9d62
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2575
movq 0x8(%r14), %rdx
subq (%r14), %rdx
cmpq $0x80, %rdx
jne 0x2575
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq %rax, %rcx
je 0x2563
movq %rsi, %r15
xorl %r13d, %r13d
leaq -0x30(%rbp), %r12
movq (%r14), %rcx
movq (%rcx,%r13,8), %rcx
xorq (%rax,%r13,8), %rcx
movq %rcx, -0x30(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x25b4
incq %r13
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jb 0x2533
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a88(%rip), %rdi      # 0x5004
leaq 0x2aae(%rip), %rsi      # 0x5031
leaq 0x2abb(%rip), %rcx      # 0x5045
movl $0x7, %edx
callq 0x20b0
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x25ab
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2130
movq %r14, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x50(%rbp)
movq %rdi, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2a76
leaq -0x48(%rbp), %rsi
leaq -0x29(%rbp), %rcx
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2af6
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x2787
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
cmpq $0x0, -0x50(%rbp)
je 0x27fa
xorl %r14d, %r14d
leaq -0x68(%rbp), %r15
leaq -0x48(%rbp), %r12
xorl %r13d, %r13d
movq (%rbx), %rsi
addq %r14, %rsi
movq %r15, %rdi
callq 0x2a76
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2872
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2d50
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x27d8
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x27ed
movq -0x58(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
incq %r13
addq $0x18, %r14
cmpq %r13, -0x50(%rbp)
jne 0x279c
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x286a
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
jmp 0x286a
movq %rax, %r14
jmp 0x286a
movq %rax, %r14
jmp 0x2862
movq %rax, %r14
jmp 0x284d
movq %rax, %r14
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x284d
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x2862
movq -0x58(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x2b40
movq %r14, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq -0x40(%rbp), %rcx
movq %rax, 0x10(%rcx)
movaps %xmm0, (%rcx)
movl $0x10, %r12d
leaq -0x48(%rbp), %r13
movzbl %r15b, %eax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
movq %r13, %rsi
callq 0x25b4
shrdq $0x8, %r14, %r15
shrq $0x8, %r14
decq %r12
jne 0x30ff
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
cmpq %rdi, %rdx
je 0x3163
addq $-0x8, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3149
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x3151
movq %rbx, %rdi
callq 0x2fe2
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
addq $-0x8, %rdx
movq %rdx, -0x38(%rbp)
jmp 0x3129
testq %rdi, %rdi
je 0x3174
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3188
movq %rax, %r14
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x31a0
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x31b4
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2130
movq %r14, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0xf0, %rsp
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
cmpq $0x80, %rcx
jne 0x3339
movq %rsi, %r12
movq %rdi, %rbx
movq (%rax), %rcx
leaq -0x108(%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 -0x88(%rbp), %r14
leaq -0x25(%rbp), %rcx
movl $0x4, %edx
movq %r14, %rdi
callq 0x2ba2
leaq -0x70(%rbp), %r15
movq (%r12), %rax
movq 0x20(%rax), %rcx
leaq -0xe8(%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 -0x24(%rbp), %rcx
movl $0x4, %edx
movq %r15, %rdi
callq 0x2ba2
leaq -0x58(%rbp), %r15
movq (%r12), %rax
movq 0x40(%rax), %rcx
leaq -0xc8(%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)
leaq -0x23(%rbp), %rcx
movl $0x4, %edx
movq %r15, %rdi
callq 0x2ba2
leaq -0x40(%rbp), %r15
movq (%r12), %rax
movq 0x60(%rax), %rcx
leaq -0xa8(%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)
leaq -0x22(%rbp), %rcx
movl $0x4, %edx
movq %r15, %rdi
callq 0x2ba2
leaq -0x88(%rbp), %rsi
leaq -0x21(%rbp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2af6
movl $0x60, %r14d
movq -0xa0(%rbp,%r14), %rdi
testq %rdi, %rdi
je 0x3320
movq -0x90(%rbp,%r14), %rsi
subq %rdi, %rsi
callq 0x2130
addq $-0x18, %r14
jne 0x3303
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1dda(%rip), %rdi      # 0x511a
leaq 0x1de6(%rip), %rsi      # 0x512d
leaq 0x1dec(%rip), %rcx      # 0x513a
movl $0x14, %edx
callq 0x20b0
movq %rax, %rbx
movl $0x60, %r14d
movq -0xa0(%rbp,%r14), %rdi
testq %rdi, %rdi
je 0x337e
movq -0x90(%rbp,%r14), %rsi
subq %rdi, %rsi
callq 0x2130
addq $-0x18, %r14
jne 0x3361
jmp 0x33ab
jmp 0x338a
jmp 0x338a
movq %rax, %rbx
movq -0x18(%r15), %rdi
testq %rdi, %rdi
je 0x33a2
movq -0x8(%r15), %rsi
subq %rdi, %rsi
callq 0x2130
addq $-0x18, %r15
cmpq %r14, %r15
jne 0x338d
movq %rbx, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3710
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq %r15, %r14
je 0x3704
leaq 0x4a57(%rip), %r12      # 0x8128
movzbl (%r14), %edx
shll $0x3, %edx
addq (%r12), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x36f3
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x36fb
movq %rbx, %rdi
callq 0x2fe2
addq $0x8, %r14
cmpq %r15, %r14
jne 0x36d1
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a03(%rip), %rdi      # 0x511a
leaq 0x1a52(%rip), %rsi      # 0x5170
leaq 0x1a5c(%rip), %rcx      # 0x5181
movl $0x6, %edx
callq 0x20b0
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3746
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2130
movq %r14, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1c4a(%rip), %rsi      # 0x5b66
leaq 0x1cc1(%rip), %rdx      # 0x5be4
leaq -0x48(%rbp), %rdi
callq 0x4200
leaq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0x4090
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x3f50
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2130
leaq -0x48(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1c87(%rip), %rsi      # 0x5be5
leaq 0x1cfe(%rip), %rdx      # 0x5c63
callq 0x4200
leaq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0x4090
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x3f8e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2130
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %r8
leaq -0x48(%rbp), %rbx
movl $0xa, %r9d
movq %rbx, %rdi
callq 0x3770
movq (%rbx), %r12
movq 0x8(%rbx), %r13
cmpq %r13, %r12
je 0x3ffa
movq 0x4015(%rip), %rbx      # 0x7fd8
leaq -0x50(%rbp), %r14
leaq 0x1c96(%rip), %r15      # 0x5c64
movq (%r12), %rax
movq %rax, -0x50(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40dd
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
addq $0x8, %r12
cmpq %r13, %r12
jne 0x3fce
movq 0x3fd7(%rip), %rdi      # 0x7fd8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq 0x3fbc(%rip), %rdi      # 0x7fd8
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x403e
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4053
jmp 0x4068
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x4087
movq -0x38(%rbp), %rsi
incq %rsi
jmp 0x4082
movq %rax, %rbx
jmp 0x4087
jmp 0x406f
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x4087
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x170, %rsp            # imm = 0x170
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x1cc6(%rip), %rsi      # 0x4190
leaq -0x40(%rbp), %rdi
callq 0x2230
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x2140
leaq 0x1cb4(%rip), %rsi      # 0x419c
leaq -0x40(%rbp), %rdi
callq 0x2230
leaq 0x1c9e(%rip), %rsi      # 0x4196
leaq -0x40(%rbp), %rdi
callq 0x2070
movl %eax, %ebx
xorl %r15d, %r15d
testl %eax, %eax
sete %r15b
callq 0x2658
movq %rax, %r14
leaq 0x1c88(%rip), %rdx      # 0x41a3
leaq 0x1c9c(%rip), %r8       # 0x41be
leaq -0x190(%rbp), %rdi
movl %r15d, %esi
movl $0xc, %ecx
xorl %r9d, %r9d
callq 0x3a58
leaq -0x190(%rbp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x391e
leaq -0x190(%rbp), %rdi
callq 0x2ae6
testl %ebx, %ebx
jne 0x25f3
callq 0x2658
movq %rax, %rbx
leaq 0x1c36(%rip), %rdx      # 0x41a3
leaq 0x1c67(%rip), %r8       # 0x41db
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0xd, %ecx
xorl %r9d, %r9d
callq 0x3a58
leaq -0x120(%rbp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x391e
leaq -0x120(%rbp), %rdi
callq 0x2ae6
callq 0x2658
movq %rax, %rbx
leaq 0x1bea(%rip), %rdx      # 0x41a3
leaq 0x1c3a(%rip), %r8       # 0x41fa
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0xf, %ecx
xorl %r9d, %r9d
callq 0x3a58
leaq -0xb0(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x391e
leaq -0xb0(%rbp), %rdi
callq 0x2ae6
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2601
callq 0x2160
addq $0x170, %rsp            # imm = 0x170
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0x2635
jmp 0x263e
movq %rax, %rbx
leaq -0x120(%rbp), %rdi
jmp 0x2635
movq %rax, %rbx
leaq -0x190(%rbp), %rdi
callq 0x2ae6
jmp 0x2641
jmp 0x263e
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x264f
callq 0x2160
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x60a9
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7d1a
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x6004
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7cda
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x7f8c(%rip), %rdi      # 0xdfd8
callq 0x2170
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6096
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
movq %r14, %rdi
callq 0x7d26
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x6004
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60d1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::traversalPrintPost(Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
void AVLTree<T>::traversalPrintPost(Node<T>* n) {
	if(n != 0) {
		traversalPrintPost(n->getLeftChild());
		traversalPrintPost(n->getRightChild());
		std::cout << "Value is " << n->getValue() << std::endl;
		std::cout << "Balance is " << n->getBalance() << endl;		
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rsi, %rsi
je 0x61ec
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7d1a
movq (%rax), %rsi
movq %r14, %rdi
callq 0x60da
movq %rbx, %rdi
callq 0x7d26
movq (%rax), %rsi
movq %r14, %rdi
callq 0x60da
movq 0x7eb9(%rip), %r14      # 0xdfd8
leaq 0x4047(%rip), %rsi      # 0xa16d
movl $0x9, %edx
movq %r14, %rdi
callq 0x2170
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7cda
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x2170
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6195
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
movq 0x7e3c(%rip), %r14      # 0xdfd8
leaq 0x3fd4(%rip), %rsi      # 0xa177
movl $0xb, %edx
movq %r14, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x7cfc
movq %r14, %rdi
movl %eax, %esi
callq 0x21d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6214
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::traversalPrintIn(Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
void AVLTree<T>::traversalPrintIn(Node<T>* n) {
	if(n != 0) {
		traversalPrintIn(n->getLeftChild());		
		std::cout << "Value is " << n->getValue() << std::endl;
		std::cout << "Balance is " << n->getBalance() << endl;
		//cout << "It's address is " << n << endl;
		traversalPrintIn(n->getRightChild());
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x6334
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7d1a
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x621c
movq 0x7d88(%rip), %r15      # 0xdfd8
leaq 0x3f16(%rip), %rsi      # 0xa16d
movl $0x9, %edx
movq %r15, %rdi
callq 0x2170
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x7cda
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x2170
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62ca
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq 0x7d07(%rip), %r15      # 0xdfd8
leaq 0x3e9f(%rip), %rsi      # 0xa177
movl $0xb, %edx
movq %r15, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x7cfc
movq %r15, %rdi
movl %eax, %esi
callq 0x21d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x7d26
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x621c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x635e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::leftRotation(Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>**)
void AVLTree<T>::leftRotation(Node<T>* cn, Node<T>** parent) {
	cout << "Left Rotation on " << cn->getValue() << endl;
	Node<T>* newRoot = cn->getRightChild();
	Node<T>* tempLC = newRoot->getLeftChild();
	*parent = newRoot;
	newRoot->setLeftChild(*cn);
	cn->setRightChild(*tempLC);	
	
	//special case
	if (tempLC != 0 && newRoot->getRightChild() != 0) newRoot->getRightChild()->incBalance();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq 0x7c5a(%rip), %r15      # 0xdfd8
leaq 0x3dfe(%rip), %rsi      # 0xa183
movl $0x11, %edx
movq %r15, %rdi
callq 0x2170
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x7cda
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x2170
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x63f8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x7d26
movq (%rax), %r15
movq %r15, %rdi
callq 0x7d1a
movq (%rax), %r12
movq %r15, (%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7d20
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7d2c
movq %r15, %rdi
callq 0x7d26
cmpq $0x0, (%rax)
je 0x6445
movq %r15, %rdi
callq 0x7d26
movq (%rax), %rdi
callq 0x7d00
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x646f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::rightRotation(Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>**)
void AVLTree<T>::rightRotation(Node<T>* cn, Node<T>** parent) {	
	cout << "Right rotation on " << cn->getValue() << endl;
	Node<T>* newRoot = cn->getLeftChild();
	Node<T>* tempRC = newRoot->getRightChild();	
	*parent = newRoot;
	newRoot->setRightChild(*cn);
	cn->setLeftChild(*tempRC);	

	//special case
	if (tempRC != 0 && newRoot->getLeftChild() != 0) newRoot->getLeftChild()->decBalance();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq 0x7b48(%rip), %r15      # 0xdfd8
leaq 0x3cfe(%rip), %rsi      # 0xa195
movl $0x12, %edx
movq %r15, %rdi
callq 0x2170
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x7cda
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x2170
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x650a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x7d1a
movq (%rax), %r15
movq %r15, %rdi
callq 0x7d26
movq (%rax), %r12
movq %r15, (%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7d2c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7d20
movq %r15, %rdi
callq 0x7d1a
cmpq $0x0, (%rax)
je 0x6557
movq %r15, %rdi
callq 0x7d1a
movq (%rax), %rdi
callq 0x7d04
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6581
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryanbarringtoncox[P]AVLTree/AVLTree.cpp
// Function: AVLTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool AVLTree<T>::find(T v) {
	Node<T>** curr =&root;
	
	while(*curr!=0 && (*curr)->getValue()!= v) {
		if (v < (*curr)->getValue()) {
			curr = &((*curr)->getLeftChild());
		} else if (v > (*curr)->getValue()) {
			curr = &((*curr)->getRightChild());
		}    
	}
	
	if (*curr==0) {
		return false;
	}
	else {
		return true;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x669f
movq %rdi, %r15
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x7cda
movq 0x10(%rsp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x65ee
movq 0x8(%rsp), %r12
testq %rdx, %rdx
je 0x65f8
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x2160
testl %eax, %eax
setne %bpl
jmp 0x65fa
movb $0x1, %bpl
movq 0x8(%rsp), %r12
jmp 0x65fa
xorl %ebp, %ebp
cmpq %r13, %r12
je 0x660f
movq 0x18(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x2150
testb %bpl, %bpl
je 0x66a3
movq (%r15), %rsi
movq %r14, %rdi
callq 0x7cda
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2040
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6647
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
testl %ebp, %ebp
js 0x6688
movq (%r15), %rsi
movq %r14, %rdi
callq 0x7cda
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2040
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x667a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
testl %ebp, %ebp
jle 0x6693
movq (%r15), %rdi
callq 0x7d26
jmp 0x6690
movq (%r15), %rdi
callq 0x7d1a
movq %rax, %r15
movq (%r15), %rsi
testq %rsi, %rsi
jne 0x65be
xorl %eax, %eax
jmp 0x66aa
cmpq $0x0, (%r15)
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x66bb
movq %rax, %rdi
callq 0x7752
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryanbarringtoncox[P]AVLTree/TwoDArray.cpp
// Function: TwoDArray<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::print()
void TwoDArray<T>::print() {	
	for(int i = 0; i < numRows; ++i) {
		for (int j = 0; j < numColumns; ++j) {
			cout << theArray[i][j]	<< " ";
		}
		cout << endl;
	}	
}

// Assembly:
cmpl $0x0, 0x18(%rdi)
jle 0x89c4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, (%rsp)
movq 0x56b7(%rip), %r14      # 0xdfd8
leaq 0x1705(%rip), %r15      # 0xa02d
cmpl $0x0, 0x1c(%rbx)
jle 0x8977
movl $0x8, %r13d
movq (%rsp), %rax
leaq (%rax,%rax,2), %rbp
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax,%rbp,8), %rax
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %r14, %rdi
callq 0x2170
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
incq %r12
movslq 0x1c(%rbx), %rax
addq $0x20, %r13
cmpq %rax, %r12
jl 0x893f
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq (%rsp), %rdx
incq %rdx
movslq 0x18(%rbx), %rax
movq %rdx, (%rsp)
cmpq %rax, %rdx
jl 0x8928
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryanbarringtoncox[P]AVLTree/TwoDArray.cpp
// Function: TwoDArray<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::TwoDArray(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
TwoDArray<T>::TwoDArray(int r, int c, T def) {
	assert(r > 0 && c > 0);	
	numRows = r;
	numColumns = c;
	deffy = def;
	theArray.resize(r);	
	for(int i = 0; i < r; ++i) {
		theArray[i].resize(c);
	}
	
	for(int i = 0; i < numRows; ++i) {
		for (int j = 0; j < numColumns; ++j) {
			theArray[i][j]=def;
		}
	}	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
testl %esi, %esi
jle 0x868a
movl %edx, %ebp
testl %edx, %edx
jle 0x868a
movl %esi, %r12d
movq %rdi, %rbx
movq %rcx, 0x10(%rsp)
addq $0x20, %rdi
movl %esi, 0x18(%rbx)
movl %ebp, 0x1c(%rbx)
movq %rdi, 0x8(%rsp)
movq %r14, %rsi
callq 0x20b0
movl %r12d, %r13d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x86de
movl %ebp, %r12d
shlq $0x3, %r13
leaq (,%r13,2), %r15
addq %r13, %r15
xorl %r13d, %r13d
movq (%rbx), %rdi
addq %r13, %rdi
movq %r12, %rsi
callq 0x875a
addq $0x18, %r13
cmpq %r13, %r15
jne 0x861a
movl 0x18(%rbx), %ecx
testl %ecx, %ecx
jle 0x867b
movl 0x1c(%rbx), %eax
xorl %r12d, %r12d
testl %eax, %eax
jle 0x8670
leaq (%r12,%r12,2), %r13
xorl %ebp, %ebp
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r13,8), %rdi
addq %rbp, %rdi
movq %r14, %rsi
callq 0x20b0
incq %r15
movslq 0x1c(%rbx), %rax
addq $0x20, %rbp
cmpq %rax, %r15
jl 0x864b
movl 0x18(%rbx), %ecx
incq %r12
movslq %ecx, %rdx
cmpq %rdx, %r12
jl 0x863e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bef(%rip), %rdi      # 0xa280
leaq 0x1bf7(%rip), %rsi      # 0xa28f
leaq 0x1dca(%rip), %rcx      # 0xa469
movl $0xd, %edx
callq 0x20d0
jmp 0x86ad
jmp 0x86ad
movq %rax, %r14
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x86cd
movq (%rax), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x878a
movq %r14, %rdi
callq 0x21e0
nop