LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x68(%rsp), %rbx
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %r8
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x16a8
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, 0x30(%rsp)
cmpq %rax, %rbx
je 0x1544
leaq 0x40(%rsp), %r14
leaq 0x38(%rsp), %r13
movq 0x2b20(%rip), %r15      # 0x3fd8
leaq 0xb71(%rip), %r12       # 0x2030
movq %r13, %rbp
movq %r13, %rdi
movq %rbx, %rsi
callq 0x172a
movq 0x50(%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 0x190a
addq $0x30, %rbx
cmpq 0x30(%rsp), %rbx
jne 0x14bf
leaq 0x10(%rsp), %rdi
callq 0x1666
leaq 0x68(%rsp), %rdi
callq 0x190a
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 0x38(%rsp), %rdi
callq 0x190a
leaq 0x10(%rsp), %rdi
callq 0x1666
leaq 0x68(%rsp), %rdi
callq 0x190a
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdi, %r14
movq 0x146d3(%rip), %rbx     # 0x16fd8
leaq 0xe6f8(%rip), %rsi      # 0x11004
movl $0x23, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2180
leaq 0xe6e1(%rip), %rsi      # 0x11028
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2230
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x2170
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2180
leaq 0xe69f(%rip), %rsi      # 0x11030
movl $0xb, %edx
movq %rbx, %rdi
callq 0x2230
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x2170
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2180
leaq 0xe661(%rip), %rsi      # 0x1103c
movl $0xd, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2180
leaq 0xe634(%rip), %rsi      # 0x1104a
movl $0xe, %edx
movq %rbx, %rdi
callq 0x2230
movsd (%r14), %xmm0
movq %rbx, %rdi
callq 0x2290
movq %rax, %r15
leaq 0xf33c(%rip), %r12      # 0x11d76
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2230
movsd 0x8(%r14), %xmm0
movq %r15, %rdi
callq 0x2290
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2230
movsd 0x10(%r14), %xmm0
movq %r15, %rdi
callq 0x2290
movq %rax, %r14
leaq 0xe5d6(%rip), %rsi      # 0x11059
movl $0x3, %edx
movq %rax, %rdi
callq 0x2230
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2180
leaq 0xe59f(%rip), %rsi      # 0x1105d
movl $0x26, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2180
// File: /workspace/github_cpp_makefile_star2_O1/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 0xba38(%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 0xba0c(%rip), %rsi      # 0x11a15
movq %r15, %rdi
callq 0x2090
testl %eax, %eax
je 0x6056
leaq 0xbe4a(%rip), %rsi      # 0x11e66
leaq -0x78(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x60a8
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0xb130
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x542c
movq -0x38(%rbp), %rdi
jmp 0x6081
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0xb130
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x43e0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x608b
callq 0x21e0
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x609d
callq 0x21e0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10f29(%rip), %rdi     # 0x16fd8
leaq 0xb965(%rip), %rsi      # 0x11a1b
movl $0x13, %edx
callq 0x2230
movq 0x10f11(%rip), %rdi     # 0x16fd8
callq 0x20f0
callq 0x2140
movq %rax, %rbx
movq -0x58(%rbp), %rdi
jmp 0x60e1
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x60f0
callq 0x21e0
jmp 0x60f0
movq %rax, %rbx
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6102
callq 0x21e0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x91c8
cmpq $0x1, %rdx
jne 0x920d
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 0xb130
movq %rbx, %rdi
movq %r14, %rsi
callq 0x610a
movq -0x58(%rbp), %rdi
jmp 0x91f8
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 0xb130
movq %rbx, %rdi
movq %r14, %rsi
callq 0x75d8
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x9202
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xddc4(%rip), %rdi      # 0x16fd8
leaq 0x8800(%rip), %rsi      # 0x11a1b
callq 0x2200
movq %rax, %rdi
callq 0x20f0
callq 0x2140
movq %rax, %rbx
movq -0x58(%rbp), %rdi
jmp 0x923d
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x9247
callq 0x21e0
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x97ca
popq %rbp
jmp 0x9a30
popq %rbp
jmp 0x9d62
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %r13d, %r13d
movq %r13, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq -0x40(%rbp), %r12
movq %r13, 0x10(%r12)
movaps %xmm0, (%r12)
movq $0xff, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
movq %r15, -0x50(%rbp)
movq %r14, -0x48(%rbp)
xorl %eax, %eax
movq -0x68(%rbp,%rax,8), %rcx
andq %rcx, -0x50(%rbp,%rax,8)
incq %rax
cmpq $0x1, %rax
je 0x312f
cmpq $0x0, -0x48(%rbp)
jne 0x31d8
movzbl -0x50(%rbp), %eax
movq %rax, -0x58(%rbp)
movq %r12, %rdi
leaq -0x58(%rbp), %rsi
callq 0x25f0
shrdq $0x8, %r14, %r15
shrq $0x8, %r14
incq %r13
cmpq $0x10, %r13
jne 0x3115
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
cmpq %rdi, %rdx
je 0x31b5
addq $-0x8, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x319b
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x31a3
movq %rbx, %rdi
callq 0x3000
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
addq $-0x8, %rdx
movq %rdx, -0x38(%rbp)
jmp 0x317b
testq %rdi, %rdi
je 0x31c6
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f91(%rip), %rdi      # 0x5170
callq 0x2160
jmp 0x31e8
jmp 0x31e8
movq %rax, %r14
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x3200
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3214
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2130
movq %r14, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8(%rsi), %rax
subq (%rsi), %rax
cmpq $0x80, %rax
jne 0x25b1
movq %rdx, %r14
movq 0x8(%rdx), %rax
subq (%rdx), %rax
cmpq $0x80, %rax
jne 0x25b1
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x259f
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 0x25f0
incq %r13
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jb 0x256f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a4c(%rip), %rdi      # 0x5004
leaq 0x2a72(%rip), %rsi      # 0x5031
leaq 0x2a7f(%rip), %rcx      # 0x5045
movl $0x7, %edx
callq 0x20b0
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x25e7
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2130
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2aaa
leaq -0x48(%rbp), %rsi
leaq -0x29(%rbp), %rcx
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2b2a
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x27bb
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
cmpq $0x0, -0x50(%rbp)
je 0x282e
xorl %r14d, %r14d
leaq -0x68(%rbp), %r15
leaq -0x48(%rbp), %r12
xorl %r13d, %r13d
movq (%rbx), %rsi
addq %r14, %rsi
movq %r15, %rdi
callq 0x2aaa
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x28a6
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2d7e
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x280c
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x2821
movq -0x58(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
incq %r13
addq $0x18, %r14
cmpq %r13, -0x50(%rbp)
jne 0x27d0
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 0x289e
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
jmp 0x289e
movq %rax, %r14
jmp 0x289e
movq %rax, %r14
jmp 0x2896
movq %rax, %r14
jmp 0x2881
movq %rax, %r14
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x2881
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x2896
movq -0x58(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x2b74
movq %r14, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3398
movq %rsi, %r12
movq %rdi, %r15
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 0x2bd0
leaq -0x70(%rbp), %rbx
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 %rbx, %rdi
callq 0x2bd0
leaq -0x58(%rbp), %rbx
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 %rbx, %rdi
callq 0x2bd0
leaq -0x40(%rbp), %rbx
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 %rbx, %rdi
callq 0x2bd0
leaq -0x88(%rbp), %rsi
leaq -0x21(%rbp), %rcx
movl $0x4, %edx
movq %r15, %rdi
callq 0x2b2a
movl $0x60, %ebx
movq -0xa0(%rbp,%rbx), %rdi
testq %rdi, %rdi
je 0x337f
movq -0x90(%rbp,%rbx), %rsi
subq %rdi, %rsi
callq 0x2130
addq $-0x18, %rbx
jne 0x3362
movq %r15, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d7b(%rip), %rdi      # 0x511a
leaq 0x1d87(%rip), %rsi      # 0x512d
leaq 0x1d8d(%rip), %rcx      # 0x513a
movl $0x14, %edx
callq 0x20b0
movq %rax, %r15
leaq -0x28(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x2245
movb $0x1, %al
jmp 0x33e1
jmp 0x33d2
jmp 0x33d2
movq %rax, %r15
xorl %eax, %eax
jmp 0x33e1
movq %rax, %r15
xorl %eax, %eax
movq %r14, %rbx
cmpq %rbx, %r14
sete %cl
orb %al, %cl
jne 0x3410
leaq -0x88(%rbp), %r14
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3407
movq -0x8(%rbx), %rsi
subq %rdi, %rsi
callq 0x2130
addq $-0x18, %rbx
cmpq %r14, %rbx
jne 0x33f2
movq %r15, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/skyleaworlder[P]AES/src/MixColumns.cpp
// Function: FieldMult(std::bitset<8ul>)
byte FieldMult(byte input) {
    std::bitset<1> top { input[7] };
    byte tmp { input << 1 };
    if (top == 1)
        return tmp ^ byte(0x1b);
    else
        return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal (%rdi,%rdi), %eax
movzbl %al, %ecx
movq %rcx, %rax
xorq $0x1b, %rax
testb %dil, %dil
cmovnsq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/skyleaworlder[P]AES/src/ShiftRows.cpp
// Function: ShiftRows(std::vector<std::bitset<8ul>, std::allocator<std::bitset<8ul>>>)
vector<byte> ShiftRows(
    vector<byte> input
) {
    return vector<byte> {
        input[0], input[5], input[10], input[15],
        input[4], input[9], input[14], input[3],
        input[8], input[13], input[2], input[7],
        input[12], input[1], input[6], input[11]
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rcx
leaq -0x90(%rbp), %rsi
movq %rcx, (%rsi)
movq 0x28(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x50(%rax), %rcx
movq %rcx, 0x10(%rsi)
movq 0x78(%rax), %rcx
movq %rcx, 0x18(%rsi)
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%rsi)
movq 0x48(%rax), %rcx
movq %rcx, 0x28(%rsi)
movq 0x70(%rax), %rcx
movq %rcx, 0x30(%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x38(%rsi)
movq 0x40(%rax), %rcx
movq %rcx, 0x40(%rsi)
movq 0x68(%rax), %rcx
movq %rcx, 0x48(%rsi)
movq 0x10(%rax), %rcx
movq %rcx, 0x50(%rsi)
movq 0x38(%rax), %rcx
movq %rcx, 0x58(%rsi)
movq 0x60(%rax), %rcx
movq %rcx, 0x60(%rsi)
movq 0x8(%rax), %rcx
movq %rcx, 0x68(%rsi)
movq 0x30(%rax), %rcx
movq %rcx, 0x70(%rsi)
movq 0x58(%rax), %rax
movq %rax, 0x78(%rsi)
leaq -0x9(%rbp), %rcx
movl $0x10, %edx
callq 0x2bd0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3778
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq %r15, %r14
je 0x376c
leaq 0x49f7(%rip), %r12      # 0x8130
movzbl (%r14), %edx
shll $0x3, %edx
addq (%r12), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x375b
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x3763
movq %rbx, %rdi
callq 0x3000
addq $0x8, %r14
cmpq %r15, %r14
jne 0x3739
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x199b(%rip), %rdi      # 0x511a
leaq 0x1a07(%rip), %rsi      # 0x518d
leaq 0x1a11(%rip), %rcx      # 0x519e
movl $0x6, %edx
callq 0x20b0
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x37ae
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2130
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d43(%rip), %rsi      # 0x5b6e
leaq 0x1dba(%rip), %rdx      # 0x5bec
leaq -0x48(%rbp), %rdi
callq 0x4154
leaq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0x3f9e
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x3e5f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2130
leaq -0x48(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x1d80(%rip), %rsi      # 0x5bed
leaq 0x1df7(%rip), %rdx      # 0x5c6b
callq 0x4154
leaq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0x3f9e
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x3e9d
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 0x37d8
movq (%rbx), %r12
movq 0x8(%rbx), %r13
cmpq %r13, %r12
je 0x3f09
movq 0x4106(%rip), %rbx      # 0x7fd8
leaq -0x50(%rbp), %r14
leaq 0x1d8f(%rip), %r15      # 0x5c6c
movq (%r12), %rax
movq %rax, -0x50(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3feb
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
addq $0x8, %r12
cmpq %r13, %r12
jne 0x3edd
movq 0x40c8(%rip), %rdi      # 0x7fd8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq 0x40ad(%rip), %rdi      # 0x7fd8
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x3f4d
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 0x3f62
jmp 0x3f77
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x3f96
movq -0x38(%rbp), %rsi
incq %rsi
jmp 0x3f91
movq %rax, %rbx
jmp 0x3f96
jmp 0x3f7e
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x3f96
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a48
leaq -0x190(%rbp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x390e
leaq -0x190(%rbp), %rdi
callq 0x2ad6
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 0x3a48
leaq -0x120(%rbp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x390e
leaq -0x120(%rbp), %rdi
callq 0x2ad6
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 0x3a48
leaq -0xb0(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x390e
leaq -0xb0(%rbp), %rdi
callq 0x2ad6
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 0x2ad6
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_O1/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 0x60e7
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7d6e
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x6042
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7d2e
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x7f4e(%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 0x60d4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
movq %r14, %rdi
callq 0x7d7a
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x6042
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 0x610f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x622a
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7d6e
movq (%rax), %rsi
movq %r14, %rdi
callq 0x6118
movq %rbx, %rdi
callq 0x7d7a
movq (%rax), %rsi
movq %r14, %rdi
callq 0x6118
movq 0x7e7b(%rip), %r14      # 0xdfd8
leaq 0x4009(%rip), %rsi      # 0xa16d
movl $0x9, %edx
movq %r14, %rdi
callq 0x2170
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7d2e
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 0x61d3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
movq 0x7dfe(%rip), %r14      # 0xdfd8
leaq 0x3f96(%rip), %rsi      # 0xa177
movl $0xb, %edx
movq %r14, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x7d50
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 0x6252
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6372
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7d6e
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x625a
movq 0x7d4a(%rip), %r15      # 0xdfd8
leaq 0x3ed8(%rip), %rsi      # 0xa16d
movl $0x9, %edx
movq %r15, %rdi
callq 0x2170
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x7d2e
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 0x6308
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq 0x7cc9(%rip), %r15      # 0xdfd8
leaq 0x3e61(%rip), %rsi      # 0xa177
movl $0xb, %edx
movq %r15, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x7d50
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 0x7d7a
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x625a
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 0x639c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7c1c(%rip), %r15      # 0xdfd8
leaq 0x3dc0(%rip), %rsi      # 0xa183
movl $0x11, %edx
movq %r15, %rdi
callq 0x2170
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x7d2e
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 0x6436
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x7d7a
movq (%rax), %r15
movq %r15, %rdi
callq 0x7d6e
movq (%rax), %r12
movq %r15, (%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7d74
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7d80
movq %r15, %rdi
callq 0x7d7a
cmpq $0x0, (%rax)
je 0x6483
movq %r15, %rdi
callq 0x7d7a
movq (%rax), %rdi
callq 0x7d54
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 0x64ad
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7b0a(%rip), %r15      # 0xdfd8
leaq 0x3cc0(%rip), %rsi      # 0xa195
movl $0x12, %edx
movq %r15, %rdi
callq 0x2170
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x7d2e
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 0x6548
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x7d6e
movq (%rax), %r15
movq %r15, %rdi
callq 0x7d7a
movq (%rax), %r12
movq %r15, (%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7d80
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7d74
movq %r15, %rdi
callq 0x7d6e
cmpq $0x0, (%rax)
je 0x6595
movq %r15, %rdi
callq 0x7d6e
movq (%rax), %rdi
callq 0x7d58
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 0x65bf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
movq (%r12), %rbp
testq %rbp, %rbp
je 0x662f
movq (%r12), %rsi
leaq 0x28(%rsp), %rdi
callq 0x7d2e
movq 0x30(%rsp), %rdx
movb $0x1, %r15b
cmpq 0x8(%rbx), %rdx
jne 0x6632
testq %rdx, %rdx
je 0x662f
movq (%rbx), %rsi
movq 0x28(%rsp), %rdi
callq 0x2160
testl %eax, %eax
setne %r15b
jmp 0x6632
xorl %r15d, %r15d
testq %rbp, %rbp
je 0x6653
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x6653
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2150
testb %r15b, %r15b
je 0x66ea
movq (%r12), %rsi
movq %r14, %rdi
callq 0x7d2e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2040
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x668c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
testl %ebp, %ebp
js 0x66d9
movq (%r12), %rsi
movq %r14, %rdi
callq 0x7d2e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2040
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x66c0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
testl %ebp, %ebp
jle 0x65f0
movq (%r12), %rdi
callq 0x7d7a
movq %rax, %r12
jmp 0x65f0
movq (%r12), %rdi
callq 0x7d6e
movq %rax, %r12
jmp 0x65f0
cmpq $0x0, (%r12)
setne %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6703
movq %rax, %rdi
callq 0x77aa
nop
// File: /workspace/github_cpp_makefile_star2_O1/ryanbarringtoncox[P]AVLTree/Node.cpp
// Function: 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>>)
Node<T>::Node(T v) {
	value = v;
	leftChild = 0;
	rightChild = 0;
	parent = 0;
	balance = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x20b0
movl $0x0, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq $0x0, 0x38(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x7d26
movq (%r15), %rsi
incq %rsi
callq 0x2150
movq %r14, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8960
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, (%rsp)
movq 0x571b(%rip), %r14      # 0xdfd8
leaq 0x1769(%rip), %r15      # 0xa02d
cmpl $0x0, 0x1c(%rbx)
jle 0x8913
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 0x88db
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 0x88c4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x862c
movl %edx, %ebp
testl %edx, %edx
jle 0x862c
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 0x8680
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 0x86fc
addq $0x18, %r13
cmpq %r13, %r15
jne 0x85c0
cmpl $0x0, 0x18(%rbx)
jle 0x861d
xorl %r12d, %r12d
cmpl $0x0, 0x1c(%rbx)
jle 0x8611
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 0x85ef
incq %r12
movslq 0x18(%rbx), %rax
cmpq %rax, %r12
jl 0x85e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c1d(%rip), %rdi      # 0xa250
leaq 0x1c25(%rip), %rsi      # 0xa25f
leaq 0x1df8(%rip), %rcx      # 0xa439
movl $0xd, %edx
callq 0x20d0
jmp 0x864f
jmp 0x864f
movq %rax, %r14
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x866f
movq (%rax), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x872c
movq %r14, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_07.cc
// Function: main
int main(int argc, char const *argv[])
{
	std::string s[] = { "sss" };
	std::cout << getSize(s) << std::endl;

	char c[] = "s";
	std::cout << getSize(c) << std::endl;
	// the output is 2, as '\0' is added at the end of the array
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xdce(%rip), %rsi       # 0x2004
leaq 0xdca(%rip), %rdx       # 0x2007
leaq -0x30(%rbp), %rdi
callq 0x12fe
movq 0x2d8b(%rip), %rdi      # 0x3fd8
movl $0x1, %esi
callq 0x1040
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movq 0x2d50(%rip), %rdi      # 0x3fd8
movl $0x2, %esi
callq 0x1040
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x12d1
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x10a0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x12de
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x12f6
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x10a0
movq %rbx, %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O1/LiGaCu[P]Distributed_System_to_Compute_the_Shortest_Path/aws.cpp
// Function: getTCPsockandbind(addrinfo*)
int getTCPsockandbind(struct addrinfo *servinfo)
{
    int sockfd;
    struct addrinfo *p;
    int reuseaddr=1;

    // loop through all the results and bind to the first we can
    for(p = servinfo; p != NULL; p = p->ai_next) 
    {
        if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) 
        {
            perror("server: socket");
            continue;
        }
        if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(int)) == -1) 
        {
            perror("setsockopt");
            exit(1);
        }
        if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) 
        {
            close(sockfd);
            perror("server: bind");
            continue;
        }
        break;
    }
    if (p == NULL) 
    {
        fprintf(stderr, "server: failed to bind\n");
        exit(1);
    }

    return sockfd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, 0x4(%rsp)
testq %rdi, %rdi
sete %r12b
je 0x30c1
movq %rdi, %rbx
leaq 0x12bf(%rip), %r15      # 0x430c
leaq 0x4(%rsp), %r14
leaq 0x12cd(%rip), %r13      # 0x4326
movl 0x4(%rbx), %edi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x2080
movl %eax, %ebp
movq %r15, %rdi
cmpl $-0x1, %eax
je 0x30ad
movl %ebp, %edi
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rcx
movl $0x4, %r8d
callq 0x2290
cmpl $-0x1, %eax
je 0x30d8
movq 0x18(%rbx), %rsi
movl 0x10(%rbx), %edx
movl %ebp, %edi
callq 0x2070
cmpl $-0x1, %eax
jne 0x30c1
movl %ebp, %edi
callq 0x22d0
movq %r13, %rdi
callq 0x2130
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
sete %r12b
jne 0x3059
jmp 0x30c1
testb $0x1, %r12b
jne 0x30dd
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x23ad
callq 0x23c2
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/tests/playsaw.cpp
// Function: usage()
void usage( void ) {
  // Error function in case of incorrect command-line
  // argument specifications
  std::cout << "\nuseage: playsaw N fs <device> <channelOffset> <time>\n";
  std::cout << "    where N = number of channels,\n";
  std::cout << "    fs = the sample rate,\n";
  std::cout << "    device = optional device to use (default = 0),\n";
  std::cout << "    channelOffset = an optional channel offset on the device (default = 0),\n";
  std::cout << "    and time = an optional time duration in seconds (default = no limit).\n\n";
  exit( 0 );
}

// Assembly:
pushq %rbx
movq 0x79c4(%rip), %rbx      # 0xbfc8
leaq 0x4a2d(%rip), %rsi      # 0x9038
movq %rbx, %rdi
callq 0x41e0
leaq 0x4a55(%rip), %rsi      # 0x906f
movq %rbx, %rdi
callq 0x41e0
leaq 0x4a69(%rip), %rsi      # 0x9092
movq %rbx, %rdi
callq 0x41e0
leaq 0x4a75(%rip), %rsi      # 0x90ad
movq %rbx, %rdi
callq 0x41e0
leaq 0x4a9a(%rip), %rsi      # 0x90e1
movq %rbx, %rdi
callq 0x41e0
leaq 0x4ad8(%rip), %rsi      # 0x912e
movq %rbx, %rdi
callq 0x41e0
xorl %edi, %edi
callq 0x4250
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/tests/playsaw.cpp
// Function: errorCallback(RtAudioError::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void errorCallback( RtAudioError::Type type, const std::string &errorText )
{
  // This example error handling function does exactly the same thing
  // as the embedded RtAudio::error() function.
  std::cout << "in errorCallback" << std::endl;
  if ( type == RtAudioError::WARNING )
    std::cerr << '\n' << errorText << "\n\n";
  else if ( type != RtAudioError::WARNING )
    throw( RtAudioError( errorText, type ) );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq 0x794f(%rip), %r14      # 0xbfc8
leaq 0x4afa(%rip), %rsi      # 0x917a
movl $0x10, %edx
movq %r14, %rdi
callq 0x4210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x41d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4150
testl %ebp, %ebp
jne 0x46fd
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movq 0x7929(%rip), %rdi      # 0xbff0
movl $0x1, %edx
callq 0x4210
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %rax, %rdi
callq 0x4210
leaq 0x4dd2(%rip), %rsi      # 0x94b9
movl $0x2, %edx
movq %rax, %rdi
callq 0x4210
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x30, %edi
callq 0x40d0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x4b04
leaq 0x74e2(%rip), %rsi      # 0xbc00
leaq 0x425(%rip), %rdx       # 0x4b4a
movq %r14, %rdi
callq 0x43b0