LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/eatonphil[P]cpp-json/json.cpp
// Function: json::lex_number(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
std::tuple<JSONToken, int, std::string> lex_number(std::string raw_json,
                                                   int original_index) {
  int index = original_index;
  JSONToken token = {"", JSONTokenType::Number, index};
  std::string value = "";
  // TODO: handle not just integers
  while (true) {
    if (index == raw_json.length()) {
      break;
    }

    auto c = raw_json[index];
    if (!(c >= '0' && c <= '9')) {
      break;
    }

    token.value += c;
    index++;
  }

  return {token, index, ""};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, -0x2c(%rbp)
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x85a3(%rip), %r12      # 0xb207
leaq -0x88(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r12, %rdx
callq 0x8c32
movl $0x1, 0x20(%r13)
movl %r15d, 0x24(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r13)
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
leaq -0x50(%rbp), %rdi
movq %r12, %rsi
movq %r12, %rdx
callq 0x8c32
movslq %r15d, %r12
cmpq %r12, 0x8(%r14)
je 0x2cde
leaq -0x88(%rbp), %r15
movq (%r14), %rax
movb (%rax,%r12), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jae 0x2cde
movsbl %al, %esi
movq %r15, %rdi
callq 0x8cd0
incq %r12
movl %r12d, -0x2c(%rbp)
movslq %r12d, %rax
cmpq %rax, 0x8(%r14)
jne 0x2cb4
leaq 0x8522(%rip), %rcx      # 0xb207
leaq -0x88(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
movq %rbx, %rdi
callq 0x6d9a
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x2d0d
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x2d1b
callq 0x6fa2
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x2d37
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d50
movq %rax, %rbx
jmp 0x2d68
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x2d68
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
leaq -0x88(%rbp), %rdi
callq 0x6734
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/eatonphil[P]cpp-json/json.cpp
// Function: json::lex_keyword(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, json::JSONTokenType, int)
std::tuple<JSONToken, int, std::string> lex_keyword(std::string raw_json,
                                                    std::string keyword,
                                                    JSONTokenType type,
                                                    int original_index) {
  int index = original_index;
  JSONToken token{"", type, index};
  while (keyword[index - original_index] == raw_json[index]) {
    if (index == raw_json.length()) {
      break;
    }

    index++;
  }

  if (index - original_index == keyword.length()) {
    token.value = keyword;
  }
  return {token, index, ""};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %r12d
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x38(%rbp)
movl %r8d, -0x2c(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x8457(%rip), %rdx      # 0xb207
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x8c32
movl %r13d, 0x20(%rbx)
movl %r12d, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq (%r14), %rax
movq (%r15), %rsi
movb (%rax), %dl
movslq %r12d, %rcx
cmpb (%rsi,%rcx), %dl
jne 0x2e14
movq 0x8(%r15), %rdx
subq %rcx, %rdx
addq %rcx, %rsi
incq %rsi
incl %ecx
xorl %edi, %edi
movq -0x38(%rbp), %rbx
cmpq %rdi, %rdx
je 0x2e1d
leal (%rcx,%rdi), %r8d
movl %r8d, -0x2c(%rbp)
movb 0x1(%rax,%rdi), %r9b
leaq 0x1(%rdi), %r8
cmpb (%rsi,%rdi), %r9b
movq %r8, %rdi
je 0x2df3
jmp 0x2e20
xorl %r8d, %r8d
movq -0x38(%rbp), %rbx
jmp 0x2e20
movq %rdx, %r8
cmpq %r8, 0x8(%r14)
jne 0x2e32
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
callq 0x8d36
leaq 0x83ce(%rip), %rcx      # 0xb207
leaq -0x70(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
movq %rbx, %rdi
callq 0x6d9a
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x2e57
callq 0x6fa2
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x2e70
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x6734
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/eatonphil[P]cpp-json/json.cpp
// Function: json::format_parse_error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, json::JSONToken)
std::string format_parse_error(std::string base, JSONToken token) {
  std::ostringstream s;
  s << "Unexpected token '" << token.value << "', type '"
    << JSONTokenType_to_string(token.type) << "', index ";
  s << std::endl << base;
  return format_error(s.str(), *token.full_source, token.location);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x200(%rbp), %r12
movq %r12, %rdi
callq 0x21f0
leaq 0x7afc(%rip), %rsi      # 0xb0dc
movl $0x12, %edx
movq %r12, %rdi
callq 0x21e0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x21e0
movq %rax, %r13
leaq 0x7ae9(%rip), %rsi      # 0xb0ef
movl $0x9, %edx
movq %rax, %rdi
callq 0x21e0
movl 0x20(%r14), %esi
leaq -0x68(%rbp), %rdi
callq 0x242c
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %r13, %rdi
callq 0x21e0
leaq 0x7ac2(%rip), %rsi      # 0xb0f9
movl $0x9, %edx
movq %rax, %rdi
callq 0x21e0
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x365d
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x200(%rbp), %rax
addq -0x18(%rax), %r12
movq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
leaq -0x200(%rbp), %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rax, %rdi
callq 0x21e0
leaq -0x1f8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x2150
movq 0x28(%r14), %rax
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x84f0
movl 0x24(%r14), %ecx
leaq -0x88(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x24ae
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x36f9
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3712
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21c0
movq 0xb89f(%rip), %rsi      # 0xefb8
leaq -0x200(%rbp), %rdi
callq 0x20f0
leaq -0x190(%rbp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x3763
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x3763
movq %rax, %rbx
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3799
movq -0x78(%rbp), %rsi
jmp 0x378c
jmp 0x3796
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3799
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x3799
movq %rax, %rbx
movq 0xb818(%rip), %rsi      # 0xefb8
leaq -0x200(%rbp), %rdi
callq 0x20f0
leaq -0x190(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/eatonphil[P]cpp-json/json.cpp
// Function: json::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::tuple<JSONValue, std::string> parse(std::string source) {
  auto [tokens, error] = json::lex(source);
  if (error.size()) {
    return {{}, error};
  }

  auto [ast, _, error1] = json::parse(tokens);
  return {ast, error1};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdi, %rbx
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 0x84f0
leaq -0x150(%rbp), %rdi
movq %r14, %rsi
callq 0x3133
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x54d7
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21c0
leaq -0x130(%rbp), %r14
cmpq $0x0, -0x18(%r14)
je 0x556c
xorl %eax, %eax
leaq -0x118(%rbp), %rsi
movb %al, 0x20(%rsi)
movb %al, 0x30(%rsi)
movb %al, 0x39(%rsi)
movb %al, 0x58(%rsi)
movb %al, 0x90(%rsi)
movl $0x0, 0x98(%rsi)
leaq -0x150(%rbp), %rdx
movq %rbx, %rdi
callq 0x82b8
cmpb $0x1, -0x88(%rbp)
jne 0x5536
leaq -0xb8(%rbp), %rdi
movb $0x0, 0x30(%rdi)
callq 0x722c
cmpb $0x1, -0xc0(%rbp)
jne 0x554f
leaq -0xd8(%rbp), %rdi
movb $0x0, 0x18(%rdi)
callq 0x683e
cmpb $0x1, -0xf8(%rbp)
jne 0x5623
leaq -0x108(%rbp), %rax
movb $0x0, 0x10(%rax)
jmp 0x560b
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x68e8
leaq -0x118(%rbp), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x3ea5
leaq -0x50(%rbp), %rdi
callq 0x6770
leaq -0xf0(%rbp), %rsi
leaq -0x118(%rbp), %rdx
movq %rbx, %rdi
callq 0x8314
cmpb $0x1, -0x60(%rbp)
jne 0x55bf
leaq -0x90(%rbp), %rdi
movb $0x0, 0x30(%rdi)
callq 0x722c
cmpb $0x1, -0x98(%rbp)
jne 0x55d8
leaq -0xb0(%rbp), %rdi
movb $0x0, 0x18(%rdi)
callq 0x683e
cmpb $0x1, -0xd0(%rbp)
jne 0x5604
leaq -0xe0(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5604
movq -0xe0(%rbp), %rsi
incq %rsi
callq 0x21c0
leaq -0x108(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5623
movq -0x108(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x6770
leaq -0x140(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x564a
movq -0x140(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0x69c8
jmp 0x568e
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x6770
jmp 0x568e
movq %rax, %rbx
jmp 0x568e
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0x6acc
leaq -0x150(%rbp), %rdi
callq 0x6bc8
jmp 0x56b4
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x56b4
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/kkloberdanz[P]Sort/main.cpp
// Function: testIsSorted()
void testIsSorted() {
    std::vector<int> V {0,1,1,1,3,3,5,6,6,7,8,8,6,8,10,10,11,11,11,12,17,17,17,17,17,19,19,20,20,21,22,22,22,23,24,24,25,25,25,26,27,27,28,28,28,30,31,33,34,36,37,40,41,42,42,43,44,44,44,45,47,47,48,49,54,54,55,55,55,57,57,57,57,58,59,59,59,59,61,62,62,63,63,64,65,65,68,68,69,70,70,72,72,72,73,73,74,76,78,78,78,79,80,80,82,84,84,85,86,87,87,89,89,90,90,90,91,91,92,93,93,93,95,98,99,99,99,39};

    std::cout << "size = " << V.size() << std::endl;
    if (kgk::isSorted(V, 0, V.size()-1)) {
        std::cout << "is sorted" << std::endl;
    } else {
        std::cout << "Not sorted" << std::endl;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
leaq 0x16a1(%rip), %rsi      # 0x3138
leaq 0x38(%rsp), %rbx
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
callq 0x10d0
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x80, %edx
movq %rbx, %rsi
callq 0x2064
movq 0x3511(%rip), %rdi      # 0x4fd8
leaq 0x15d6(%rip), %rsi      # 0x30a4
movl $0x7, %edx
callq 0x1140
movq 0x10(%rsp), %rsi
subq 0x8(%rsp), %rsi
sarq $0x2, %rsi
movq 0x34eb(%rip), %rdi      # 0x4fd8
callq 0x1090
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1cca
movq 0x10(%rsp), %rax
subq 0x8(%rsp), %rax
shrq $0x2, %rax
decl %eax
movq 0x20(%rsp), %rdi
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
negq %rcx
movq $-0x1, %rdx
leaq (%rcx,%rdx), %rsi
cmpq $-0x1, %rsi
je 0x1b87
movl 0x8(%rdi,%rdx,4), %esi
leaq 0x1(%rdx), %rbx
cmpl 0x4(%rdi,%rdx,4), %esi
movq %rbx, %rdx
jge 0x1b51
movslq %eax, %r14
callq 0x1100
cmpq %r14, %rbx
jge 0x1b91
movl $0xa, %edx
leaq 0x1531(%rip), %rsi      # 0x30b6
jmp 0x1b9d
testq %rdi, %rdi
je 0x1b91
callq 0x1100
movl $0x9, %edx
leaq 0x150f(%rip), %rsi      # 0x30ac
movq 0x3434(%rip), %rbx      # 0x4fd8
movq %rbx, %rdi
callq 0x1140
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x1120
movsbl %al, %esi
movq 0x340e(%rip), %rdi      # 0x4fd8
callq 0x1030
movq %rax, %rdi
callq 0x10a0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1be6
callq 0x1100
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c03
callq 0x1100
movq %rbx, %rdi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O3/kkloberdanz[P]Sort/main.cpp
// Function: main
int main() {
    //testIsSorted();
    test();
    timeAnalysis();
    return 0;
}

// Assembly:
pushq %rax
callq 0x17c2
callq 0x130c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/kkloberdanz[P]Sort/./sort.cpp
// Function: std::vector<int, std::allocator<int>> kgk::sort<int>(std::vector<int, std::allocator<int>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<T> sort(std::vector<T> V, std::string algo) {
    if (algo == "quick") {
        quicksort(V, 0, V.size()-1);
    } else if (algo == "insertion") {
        insertionsort(V);
    } else {
        std::exit(EXIT_FAILURE);
    }
    return V;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x12f6(%rip), %rsi      # 0x3055
movq %rdx, %rdi
callq 0x1050
testl %eax, %eax
je 0x1d88
leaq 0x1328(%rip), %rsi      # 0x309a
movq %r15, %rdi
callq 0x1050
testl %eax, %eax
jne 0x1dc6
movq %r14, %rdi
callq 0x22c1
jmp 0x1d9f
movq 0x8(%r14), %rdx
subq (%r14), %rdx
shrq $0x2, %rdx
decl %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x21d5
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %edi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O3/kkloberdanz[P]Sort/./sort.cpp
// Function: void kgk::quicksort<int>(std::vector<int, std::allocator<int>>&, int, int)
void quicksort(std::vector<T> & V, int lo, int hi) {
    
    if (isSorted(V, lo, hi)) {
        return;
    }

    if (hi - lo < 100) {
        insertionsort(V, lo, hi);
    }

    unsigned int p;
    if (lo < hi) {
        p = partition(V, lo, hi);
        quicksort(V, lo, p-1);
        quicksort(V, p+1, hi);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1cca
movslq %ebp, %rax
movl %ebx, %r12d
subl %eax, %r12d
movl %ebp, %ecx
cmovgl %ebx, %ecx
movq (%r15), %rdi
movslq %ecx, %rcx
decq %rax
negq %rcx
leaq (%rcx,%rax), %rdx
cmpq $-0x1, %rdx
je 0x22a8
movl 0x8(%rdi,%rax,4), %edx
leaq 0x1(%rax), %r15
cmpl 0x4(%rdi,%rax,4), %edx
movq %r15, %rax
jge 0x2212
movslq %ebx, %r13
callq 0x1100
cmpq %r13, %r15
jge 0x22b2
cmpl $0x63, %r12d
jg 0x2279
movq (%r14), %rax
movl %ebp, %ecx
testl %ecx, %ecx
jle 0x2273
movl %ecx, %esi
leaq 0x1(%rsi), %rdx
movl (%rax,%rsi,4), %esi
leal -0x2(%rdx), %edi
movl (%rax,%rdi,4), %r8d
cmpl %esi, %r8d
jle 0x2273
movl %r8d, -0x4(%rax,%rdx,4)
movl %esi, (%rax,%rdi,4)
decq %rdx
cmpq $0x1, %rdx
ja 0x2256
incl %ecx
cmpl %ebx, %ecx
jne 0x2249
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x2315
movl %eax, %r15d
leal -0x1(%r15), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x21d5
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x21d5
jmp 0x22b2
testq %rdi, %rdi
je 0x22b2
callq 0x1100
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kkloberdanz[P]Sort/./sort.cpp
// Function: void kgk::insertionsort<int>(std::vector<int, std::allocator<int>>&)
void insertionsort(std::vector<T> & V) {
    unsigned int j;
    T tmp;
    for (unsigned int i = 1; i < V.size(); i++) {
        j = i;
        while ((j > 0) && (V[j-1] > V[j])) {
            tmp = V[j];
            V[j] = V[j-1];
            V[j-1] = tmp;
            j--;
        }
    }
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq $0x2, %rcx
jb 0x2314
movl $0x1, %edx
xorl %esi, %esi
testl %edx, %edx
je 0x230b
movl %edx, %r8d
leaq (%rax,%r8,4), %rdi
movl (%rax,%r8,4), %r8d
movl %esi, %r9d
movl %r9d, %r9d
movl (%rax,%r9,4), %r10d
cmpl %r8d, %r10d
jle 0x230b
movl %r10d, (%rdi)
movl %r8d, (%rax,%r9,4)
addq $-0x4, %rdi
addl $-0x1, %r9d
jb 0x22ee
incl %edx
incl %esi
cmpq %rdx, %rcx
ja 0x22dc
retq
// File: /workspace/github_cpp_makefile_star2_O3/kkloberdanz[P]Sort/./sort.cpp
// Function: int kgk::partition<double>(std::vector<double, std::allocator<double>>&, int, int)
int partition(std::vector<T> & V, int lo, int hi) {
    T pivot = V[hi];
    int i = lo;
    int tmp;
    for (int j = lo; j < hi; j++) {
        if (V[j] <= pivot) {
            tmp = V[i];
            V[i] = V[j];
            V[j] = tmp;
            i++;
        }
    }

    tmp = V[i];
    V[i] = V[hi];
    V[hi] = tmp;

    return i;
}

// Assembly:
movslq %edx, %rcx
movq (%rdi), %rdx
movsd (%rdx,%rcx,8), %xmm0
cmpl %ecx, %esi
jge 0x29f8
movslq %esi, %rax
movsd (%rdx,%rax,8), %xmm1
ucomisd %xmm1, %xmm0
jb 0x29eb
movslq %esi, %rsi
movsd (%rdx,%rsi,8), %xmm2
movsd %xmm1, (%rdx,%rsi,8)
cvttpd2dq %xmm2, %xmm1
cvtdq2pd %xmm1, %xmm1
movlpd %xmm1, (%rdx,%rax,8)
incl %esi
incq %rax
cmpq %rax, %rcx
jne 0x29c4
movsd (%rdx,%rcx,8), %xmm0
movslq %esi, %rax
movsd (%rdx,%rax,8), %xmm1
movsd %xmm0, (%rdx,%rax,8)
cvttpd2dq %xmm1, %xmm0
cvtdq2pd %xmm0, %xmm0
movlps %xmm0, (%rdx,%rcx,8)
retq
// File: /workspace/github_cpp_makefile_star2_O3/kkloberdanz[P]Sort/./sort.cpp
// Function: void kgk::insertionsort<double>(std::vector<double, std::allocator<double>>&, int, int)
void insertionsort(std::vector<T> & V, int lo, int hi) {
    int j;
    int tmp;
    for (int i = lo; i < hi; i++) {
        j = i;
        while ((j > 0) && (V[j-1] > V[j])) {
            tmp = V[j];
            V[j] = V[j-1];
            V[j-1] = tmp;
            j--;
        }
    }
}

// Assembly:
cmpl %edx, %esi
jge 0x29b1
movq (%rdi), %rax
leal 0x1(%rsi), %ecx
testl %esi, %esi
jle 0x29a9
movl %esi, %edi
decq %rdi
movl %ecx, %r8d
movl %edi, %r9d
movsd (%rax,%r9,8), %xmm0
movsd 0x8(%rax,%rdi,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x29a9
movsd %xmm0, 0x8(%rax,%rdi,8)
cvttpd2dq %xmm1, %xmm0
cvtdq2pd %xmm0, %xmm0
movlpd %xmm0, (%rax,%r9,8)
decl %r8d
decq %rdi
cmpl $0x1, %r8d
jg 0x2974
incl %esi
incl %ecx
cmpl %edx, %esi
jne 0x2968
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-cardinality.cc
// Function: google_extremal_sets::AllMaximalSetsCardinality::DumpMaximalSets(std::vector<google_extremal_sets::SetProperties*, std::allocator<google_extremal_sets::SetProperties*>>*, google_extremal_sets::OutputModeEnum)
void AllMaximalSetsCardinality::DumpMaximalSets(
    std::vector<SetProperties*>* unindexed_sets,
    OutputModeEnum output_mode) {
  for (unsigned int i = 0; i < unindexed_sets->size(); ++i) {
    SetProperties* maximal_set = (*unindexed_sets)[i];
    FoundMaximalSet(*maximal_set, output_mode);
    SetProperties::Delete(maximal_set);
  }
  unindexed_sets->clear();
  for (unsigned int i = 0; i < candidates_.size(); ++i) {
    CandidateList& candidate_set = candidates_[i];
    for (unsigned int j = 0; j < candidate_set.size(); ++j) {
      SetProperties* maximal_set = candidate_set[j];
      if (maximal_set) {
        FoundMaximalSet(*maximal_set, output_mode);
        SetProperties::Delete(maximal_set);
      }
    }
    candidate_set.clear();
  }
  candidates_.clear();
  std::cout << std::flush;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
cmpq %rax, %rdx
je 0x2a3b
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %r12
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x2b0c
movq %r12, %rdi
callq 0x417c
movl %ebp, %ecx
movq (%r15), %rax
movq 0x8(%r15), %rdx
movq %rdx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
incl %ebp
cmpq %rcx, %rsi
ja 0x2a08
cmpq %rax, %rdx
je 0x2a44
movq %rax, 0x8(%r15)
leaq 0x18(%r14), %rax
movq %rax, (%rsp)
movq 0x18(%r14), %rsi
cmpq %rsi, 0x20(%r14)
je 0x2ae9
xorl %r13d, %r13d
leaq (,%r13,2), %rax
addq %r13, %rax
leaq (%rsi,%rax,8), %r15
movq (%r15), %rax
movq 0x8(%r15), %rcx
cmpq %rax, %rcx
je 0x2ab7
movl $0x1, %ebp
xorl %edx, %edx
movq (%rax,%rdx,8), %r12
testq %r12, %r12
je 0x2aa4
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x2b0c
movq %r12, %rdi
callq 0x417c
movq (%r15), %rax
movq 0x8(%r15), %rcx
movl %ebp, %edx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
incl %ebp
cmpq %rdx, %rsi
ja 0x2a7f
cmpq %rax, %rcx
je 0x2ac0
movq %rax, 0x8(%r15)
incl %r13d
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %r13, %rax
ja 0x2a5d
movq (%rsp), %rdi
callq 0x2e72
movq 0x54d7(%rip), %rdi      # 0x7fd0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-cardinality.cc
// Function: google_extremal_sets::AllMaximalSetsCardinality::FoundMaximalSet(google_extremal_sets::SetProperties const&, google_extremal_sets::OutputModeEnum)
void AllMaximalSetsCardinality::FoundMaximalSet(
    const SetProperties& maximal_set, OutputModeEnum output_mode) {
  ++maximal_sets_count_;
  switch (output_mode) {
    case COUNT_ONLY:
      break;
    case ID:
      std::cout << maximal_set.set_id << '\n';
      break;
    case ID_AND_ITEMS:
      std::cout << maximal_set << '\n';
      break;
    default:
      std::cout << "Huh?\n";
      assert(0);
      break;
  }
}

// Assembly:
pushq %rax
incq (%rdi)
testl %edx, %edx
je 0x2b54
cmpl $0x2, %edx
je 0x2b33
cmpl $0x1, %edx
jne 0x2b56
movl (%rsi), %esi
movq 0x54a9(%rip), %rdi      # 0x7fd0
callq 0x20f0
leaq 0x6(%rsp), %rsi
jmp 0x2b44
movq 0x5496(%rip), %rdi      # 0x7fd0
callq 0x4181
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x21e0
popq %rax
retq
movq 0x5473(%rip), %rdi      # 0x7fd0
leaq 0x25a2(%rip), %rsi      # 0x5106
callq 0x2190
leaq 0x24dc(%rip), %rdi      # 0x504c
leaq 0x24d7(%rip), %rsi      # 0x504e
leaq 0x258e(%rip), %rcx      # 0x510c
movl $0xf5, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/olegstrelnikov[P]thread-pool/./include/thread-pool.hpp
// Function: ThreadPool::~ThreadPool()
~ThreadPool() {
		{
			std::lock_guard<std::mutex> guard(m_);
			active_ = false;
		}
		cv_.notify_all();
		for (auto& thread: threads_) {
			thread.join();
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x21c0
testl %eax, %eax
jne 0x2d94
movb $0x0, (%rbx)
movq %r14, %rdi
callq 0x2110
leaq 0x60(%rbx), %r14
movq %r14, %rdi
callq 0x2200
movq 0x48(%rbx), %r15
movq 0x50(%rbx), %r12
cmpq %r12, %r15
je 0x2d57
movq %r15, %rdi
callq 0x2210
addq $0x8, %r15
jmp 0x2d44
leaq 0x48(%rbx), %r15
movq %r14, %rdi
callq 0x2230
movq %r15, %rdi
callq 0x2f84
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
cmpq %rbx, %rdi
je 0x2d88
movq (%rdi), %r14
callq 0x2160
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x2d78
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x20e0
jmp 0x2d9d
movq %rax, %rdi
callq 0x2fb8
nop
// File: /workspace/github_cpp_makefile_star2_O3/olegstrelnikov[P]thread-pool/./include/thread-pool.hpp
// Function: ThreadPool::worker_()
void worker_() {
		task_t task = nullptr;
		while (true) {
			{
				std::unique_lock<std::mutex> lock(m_);
				if (!tasks_.empty()) {
					task = tasks_.front();
					tasks_.erase(tasks_.begin());
				} else if (!active_) {
					break;
				} else {
					cv_.wait(lock);
					continue;
				}
			}
			if (task) {
				task();
				task = nullptr;
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %r13
leaq 0x8(%rdi), %rbp
leaq 0x60(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rsp, %r15
movq %r13, (%rsp)
movb $0x0, 0x8(%rsp)
movq %r15, %rdi
callq 0x322a
movb $0x1, 0x8(%rsp)
movq (%rbp), %r12
cmpq %rbp, %r12
je 0x2f51
movq 0x10(%r12), %r14
decq 0x18(%rbx)
movq %r12, %rdi
callq 0x21e0
movq %r12, %rdi
callq 0x2160
movq %r15, %rdi
callq 0x3214
testq %r14, %r14
je 0x2f07
callq *%r14
jmp 0x2f07
cmpb $0x1, (%rbx)
jne 0x2f6d
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x2070
movq %r15, %rdi
callq 0x3214
jmp 0x2f07
movq %rsp, %rdi
callq 0x3214
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CoderUper[P]BTree/BTree.cpp
// Function: BTree::release(Node*)
void BTree::release(Node* root)
{
    if(root)
    {
        for(int i=0;i<root->child_num;i++)
        {
            if(!root->is_leaf)
            {
               release(root->child[i]);
            }
        }       
        delete root;
        root=NULL;
    }
}

// Assembly:
testq %rsi, %rsi
je 0x1821
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x6c(%rsi), %eax
testl %eax, %eax
jle 0x180a
movq %rdi, %r14
xorl %r15d, %r15d
cmpb $0x0, 0x78(%rbx)
jne 0x17ff
movq 0x30(%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x17ca
movl 0x6c(%rbx), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x17e9
movl $0x80, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1150
retq
// File: /workspace/github_cpp_makefile_star2_O3/CoderUper[P]BTree/BTree.cpp
// Function: BTree::search(long)
Node* BTree::search(keyType key)
{
    Node* v=root;
    while(v)
    {
        int pos=v->search(key);  //在root中找不大于key的第一个节点
        /*
        if(key==30)
        {
            std::cout<<v->key[0]<<std::endl;
            std::cout<<"in BTree search pos :"<<pos<<std::endl;
           
        }
        */
        if(pos>=0&&v->key[pos]==key) return v;
        hot=v;
        if(v->is_leaf) return NULL;
        v=v->child[pos+1];
    }
    return NULL;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x1871
pushq %rbp
movq %rsp, %rbp
movl 0x68(%rax), %ecx
testl %ecx, %ecx
jle 0x1856
xorl %edx, %edx
cmpq %rsi, (%rax,%rdx,8)
jg 0x1847
incq %rdx
cmpq %rdx, %rcx
jne 0x1837
jmp 0x1849
movl %edx, %ecx
testl %ecx, %ecx
jle 0x1856
leal -0x1(%rcx), %edx
cmpq %rsi, (%rax,%rdx,8)
je 0x186f
movq %rax, 0x10(%rdi)
cmpb $0x0, 0x78(%rax)
jne 0x186d
movslq %ecx, %rcx
movq 0x30(%rax,%rcx,8), %rax
testq %rax, %rax
jne 0x182e
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/CoderUper[P]BTree/BTree.cpp
// Function: BTree::insert(long)
bool BTree::insert(keyType key)
{
    Node* node=search(key);
    if(node) return false;
    node=hot;
    int pos=node->search(key);
    node->key_insert(pos+1,key);
    node->child_insert(pos+1,NULL);
    num++;
    SolveOverflow(node);
    //std::cout<<"insert successful\n";
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1822
movq %rax, %r14
testq %rax, %rax
jne 0x18f7
movq 0x10(%rbx), %rsi
movl 0x68(%rsi), %eax
testl %eax, %eax
jle 0x18ac
xorl %ecx, %ecx
cmpq %r15, (%rsi,%rcx,8)
jg 0x1908
incq %rcx
cmpq %rcx, %rax
jne 0x189e
movl %eax, %edx
movslq %edx, %rcx
movq %r15, (%rsi,%rcx,8)
incl %eax
movl %eax, 0x68(%rsi)
movslq 0x6c(%rsi), %rax
movslq %edx, %rcx
cmpl %edx, %eax
jle 0x18de
movq %rax, %rdx
movq 0x28(%rsi,%rdx,8), %rdi
movq %rdi, 0x30(%rsi,%rdx,8)
leaq -0x1(%rdx), %rdi
movq %rdi, %rdx
cmpq %rcx, %rdi
jg 0x18c8
movq $0x0, 0x30(%rsi,%rcx,8)
incl %eax
movl %eax, 0x6c(%rsi)
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0x192c
testq %r14, %r14
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl %ecx, %eax
jle 0x1928
movq %rax, %rdx
movq -0x8(%rsi,%rdx,8), %rdi
movq %rdi, (%rsi,%rdx,8)
leaq -0x1(%rdx), %rdi
movq %rdi, %rdx
cmpq %rcx, %rdi
jg 0x190f
movl %ecx, %edx
jmp 0x18b1
movl %ecx, %edx
jmp 0x18ae
// File: /workspace/github_cpp_makefile_star2_O3/CoderUper[P]BTree/BTree.cpp
// Function: BTree::remove(long)
bool BTree::remove(keyType key)
{
    Node* node=search(key);
    if(!node) return false;  //没找到指定元素
    int pos=node->search(key);
    if(!node->is_leaf)   //若ndoe为非叶节点，找到其中序下的直接后继
    {
        Node* p=node->child[pos+1];
        while(!p->is_leaf) p=p->child[0];
        node->key[pos]=p->key[0];
        node=p;
        pos=0;
    }
    node->key_remove(pos);
    node->child_remove(pos);
    num--;
    SolveUnderflow(node);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1822
movq %rax, %r14
testq %rax, %rax
je 0x1cf0
movl 0x68(%r14), %eax
testl %eax, %eax
jle 0x1c94
xorl %ecx, %ecx
cmpq %r15, (%r14,%rcx,8)
jg 0x1c92
incq %rcx
cmpq %rcx, %rax
jne 0x1c82
jmp 0x1c94
movl %ecx, %eax
leal -0x1(%rax), %r15d
cmpb $0x0, 0x78(%r14)
je 0x1ca4
movq %r14, %r12
jmp 0x1ccc
cltq
leaq (%r14,%rax,8), %rax
addq $0x30, %rax
movq (%rax), %r12
leaq 0x30(%r12), %rax
cmpb $0x1, 0x78(%r12)
jne 0x1cae
movq (%r12), %rax
movslq %r15d, %rcx
movq %rax, (%r14,%rcx,8)
xorl %r15d, %r15d
movq %r12, %rdi
movl %r15d, %esi
callq 0x2348
movq %r12, %rdi
movl %r15d, %esi
callq 0x239a
decl 0x8(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1d00
testq %r14, %r14
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CoderUper[P]BTree/./struct.h
// Function: Node::key_remove(int)
int key_remove(int pos)
    {
        if(pos<0||pos>=key_num)
        {
            std::cout<<"key range error\n";
            return 0;
        }
        int e=key[pos];
        for(int i=pos;i<key_num;i++)
            key[i]=key[i+1];
        key_num--;
        return e;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
js 0x237d
movl 0x68(%rdi), %ecx
cmpl %esi, %ecx
jle 0x237d
movl %esi, %eax
leaq (%rdi,%rax,8), %rdx
addq $0x8, %rdx
movq -0x8(%rdx), %rax
movq (%rdx), %r8
movq %r8, -0x8(%rdx)
addq $0x8, %rdx
incl %esi
cmpl %esi, %ecx
jg 0x2365
decl %ecx
movl %ecx, 0x68(%rdi)
jmp 0x2397
movq 0x2c54(%rip), %rdi      # 0x4fd8
leaq 0xd94(%rip), %rsi       # 0x311f
movl $0x10, %edx
callq 0x1170
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CoderUper[P]BTree/./struct.h
// Function: Node::child_remove(int)
Node* child_remove(int pos)
    {
        if(pos<0||pos>=child_num)
        {
            std::cout<<"child range error\n";
            return 0;
        }
        Node* v=child[pos];
        for(int i=pos;i<child_num;i++)
            child[i]=child[i+1];
        child_num--;
        return v;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
js 0x23cf
movl 0x6c(%rdi), %ecx
cmpl %esi, %ecx
jle 0x23cf
movl %esi, %eax
leaq (%rdi,%rax,8), %rdx
addq $0x38, %rdx
movq -0x8(%rdx), %rax
movq (%rdx), %r8
movq %r8, -0x8(%rdx)
addq $0x8, %rdx
incl %esi
cmpl %esi, %ecx
jg 0x23b7
decl %ecx
movl %ecx, 0x6c(%rdi)
jmp 0x23e9
movq 0x2c02(%rip), %rdi      # 0x4fd8
leaq 0xd53(%rip), %rsi       # 0x3130
movl $0x12, %edx
callq 0x1170
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ParkerLab[P]cta/src/cta.cpp
// Function: is_gzipped_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool is_gzipped_file(const std::string& filename) {
    bool gzipped = false;
    FILE* f = fopen(filename.c_str(), "rb");

    if (f == NULL) {
        throw FileException("Could not open file \"" + filename + "\": " + strerror(errno));
    } else {
        if (fgetc(f) == 0x1f && fgetc(f) == 0x8b) {
            gzipped = true;
        }
    }
    fclose(f);
    return gzipped;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x1d40e(%rip), %rsi     # 0x29178
callq 0xb570
testq %rax, %rax
je 0xbdb0
movq %rax, %rbx
movq %rax, %rdi
callq 0xb700
cmpl $0x1f, %eax
jne 0xbd97
movq %rbx, %rdi
callq 0xb700
cmpl $0x8b, %eax
sete %bpl
jmp 0xbd99
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xb460
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xb260
movq %rax, %rbx
leaq 0x1d3b7(%rip), %rsi     # 0x2917b
movq %rsp, %rdi
movq %r14, %rdx
callq 0xf026
leaq 0x1d3bb(%rip), %rsi     # 0x29191
movq %rsp, %rdi
callq 0xb880
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xbdff
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0xbe0c
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0xb060
movl (%rax), %edi
callq 0xb190
movq %r14, %rdi
movq %rax, %rsi
callq 0xb880
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xbe62
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xbe6f
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
movq 0x8(%rax), %rdx
leaq 0x40(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xb5c0
leaq 0x2f14b(%rip), %rax     # 0x3afe8
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x2f117(%rip), %rsi     # 0x3afc0
movq 0x310c0(%rip), %rdx     # 0x3cf70
movq %rbx, %rdi
callq 0xb7b0
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0xbeda
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xb480
jmp 0xbeda
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xbef1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb480
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbf0c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb480
testb %bpl, %bpl
jne 0xbf36
jmp 0xbf3e
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbf36
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb480
jmp 0xbf36
movq %rax, %r14
movq %rbx, %rdi
callq 0xb380
movq %r14, %rdi
callq 0xb7d0
// File: /workspace/github_cpp_makefile_star2_O3/ParkerLab[P]cta/src/cta.cpp
// Function: complement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string complement(const std::string& seq) {
    std::string complemented;
    for (const auto it : seq) {
        complemented += nucleotide_complements.at(it);
    }
    return complemented;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0xc0b2
movq (%rsi), %rbp
xorl %r12d, %r12d
leaq 0x31972(%rip), %r14     # 0x3d9f8
leaq 0xf(%rsp), %r15
movb (%rbp,%r12), %al
movb %al, 0xf(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xf1fc
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0xb3e0
incq %r12
cmpq %r12, %r13
jne 0xc08b
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0xc0e1
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0xb480
movq %r14, %rdi
callq 0xb7d0
// File: /workspace/github_cpp_makefile_star2_O3/ParkerLab[P]cta/src/cta.cpp
// Function: shares_kmer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
bool shares_kmer(const std::string& s1, const std::string& s2, int k) {
    // return true if any kmer from s1 is in s2, else false

    // get all s1 kmers
    std::unordered_set<std::string> kmers;
    for (int i = 0; i <= s1.size() - k; i++) {
        kmers.insert(s1.substr(i, k));
    }


    // check if any kmer from s2 is in the set
    for (int i = 0; i <= s2.size() - k; i++) {
        if (kmers.count(s2.substr(i, k)) > 0) {
            return true;
        }
    }

    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x60(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movslq %edx, %r14
movq $-0x1, %r12
leaq 0x8(%rsp), %r13
leaq 0x30(%rsp), %rbp
incq %r12
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0xb4c0
movq %rbp, 0x28(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
leaq 0x28(%rsp), %rdx
callq 0x1f080
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xc1c8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb480
movq 0x8(%r15), %rax
subq %r14, %rax
cmpq %r12, %rax
ja 0xc183
movq $-0x1, %r15
leaq 0x8(%rsp), %r12
leaq 0x30(%rsp), %r13
incq %r15
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xb4c0
movq %r13, %rdi
movq %r12, %rsi
callq 0x1f480
movq %rax, %rbp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xc223
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb480
testq %rbp, %rbp
jne 0xc234
movq 0x8(%rbx), %rax
subq %r14, %rax
cmpq %r15, %rax
ja 0xc1e5
testq %rbp, %rbp
setne %bl
leaq 0x30(%rsp), %rdi
callq 0xfdc6
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc259
jmp 0xc25e
movq %rax, %rbx
jmp 0xc27d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xc27d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb480
leaq 0x30(%rsp), %rdi
callq 0xfdc6
movq %rbx, %rdi
callq 0xb7d0
// File: /workspace/github_cpp_makefile_star2_O3/ParkerLab[P]cta/src/cta.cpp
// Function: getFileContent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bool>>>&)
bool getFileContent(std::string fileName, std::map<std::string,bool> & vecOfStrs)
{

	// Open the File
	std::ifstream in(fileName.c_str());

	// Check if object is valid
	if(!in)
		{
			std::cerr << "Cannot open the File : "<<fileName<<std::endl;
			return false;
		}

	std::string str;
	// Read the next line from File untill it reaches the end.
	while (std::getline(in, str))
		{
			// Line contains string of length > 0 then save it in vector
			if(str.size() > 0)
				vecOfStrs[str] = true;
		}
	//Close The File
	in.close();
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movl $0x8, %edx
callq 0xb820
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x48(%rsp,%rax), %ebp
testb $0x5, %bpl
je 0xd268
movq 0x2fdd3(%rip), %rdi     # 0x3cfe8
leaq 0x1c68a(%rip), %rsi     # 0x298a6
movl $0x17, %edx
callq 0xb540
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x2fdb4(%rip), %rdi     # 0x3cfe8
callq 0xb540
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb440
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb040
movq %rax, %rdi
callq 0xb330
jmp 0xd2fa
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq (%rsp,%rax), %rdi
addq $0x28, %rdi
movl $0xa, %esi
callq 0xb440
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0xb830
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xd2d9
cmpq $0x0, 0x10(%rsp)
je 0xd2ce
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf2d0
movb $0x1, (%rax)
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
jmp 0xd28a
leaq 0x28(%rsp), %rdi
callq 0xb0d0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xd2fa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb480
testb $0x5, %bpl
sete %bl
leaq 0x28(%rsp), %rdi
callq 0xb110
movl %ebx, %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd324
movq %rax, %rbx
jmp 0xd33e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xd33e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb480
leaq 0x28(%rsp), %rdi
callq 0xb110
movq %rbx, %rdi
callq 0xb7d0
// File: /workspace/github_cpp_makefile_star2_O3/ParkerLab[P]cta/src/cta.cpp
// Function: FASTQRecord::append_barcode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void append_barcode(const std::string& barcode) {
        if (name.find(' ')!=std::string::npos) {
                name.insert(name.find(' '), "_" + barcode);
        } else {
                name += "_" + barcode;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x20, %esi
xorl %edx, %edx
callq 0xb600
cmpq $-0x1, %rax
je 0xfc02
movq %rbx, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0xb600
movq %rax, %r15
leaq 0x19d84(%rip), %rsi     # 0x2995e
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rdx
callq 0xf026
movq (%r12), %rcx
movq 0x8(%r12), %r8
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xb520
jmp 0xfc28
leaq 0x19d55(%rip), %rsi     # 0x2995e
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0xf026
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0xb160
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfc43
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb480
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xfc51
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfc6f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb480
movq %rbx, %rdi
callq 0xb7d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ReadMappingReader.cpp
// Function: Bio::VectorReader::next_mapping()
ReadMapping* VectorReader::next_mapping()
{
        ReadMapping* r = NULL;

        if(it==read_mappings.end())
                return NULL;

        try {
                r = new ReadMapping(*(*(it)));
        }
        catch(exception& e) {
		throw Software_bug("Failed to allocate new ReadMapping", "", __PRETTY_FUNCTION__);
        }
	it++;

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x20(%rdi), %r15
cmpq 0x10(%rdi), %r15
je 0x6791
movq %rdi, %r14
movl $0xe8, %edi
callq 0x42b0
movq %rax, %rbx
movq (%r15), %rsi
movq %rax, %rdi
callq 0x6c76
addq $0x8, 0x20(%r14)
jmp 0x6793
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x4280
jmp 0x67bb
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x6890
movq %r14, %rdi
callq 0x4120
movl $0x28, %edi
callq 0x4150
movq %rax, %rbx
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xab77(%rip), %rsi      # 0x11360
leaq 0xab92(%rip), %rdx      # 0x11382
leaq -0x48(%rbp), %rdi
callq 0x6440
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xaa62(%rip), %rdx      # 0x1126a
leaq -0x68(%rbp), %rdi
movq %rdx, %rsi
callq 0x6440
movb $0x1, %r12b
leaq 0xab65(%rip), %rcx      # 0x11383
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
movq %rbx, %rdi
callq 0x6e40
xorl %r12d, %r12d
leaq 0x110d8(%rip), %rsi     # 0x17910
leaq 0xcb7(%rip), %rdx       # 0x74f6
movq %rbx, %rdi
callq 0x44c0
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x6858
callq 0x4280
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x6866
callq 0x4280
testb %r12b, %r12b
jne 0x6883
jmp 0x688b
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x6883
callq 0x4280
jmp 0x6883
movq %rax, %r14
movq %rbx, %rdi
callq 0x41f0
callq 0x4490
movq %r14, %rdi
callq 0x44f0
movq %rax, %rdi
callq 0x7529
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ReadMappingReader.cpp
// Function: Bio::FileReader::restart()
void FileReader::restart()
{
	if(m_fp)
		fclose(m_fp);
	if((m_fp = fopen(this->file_name().c_str(), "r")) == NULL)
		throw Bio::Bad_file(this->file_name(), "Failed to re-open file", __PRETTY_FUNCTION__);
	m_total_to_read = filesize(m_file_name.c_str());
	m_total_read = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x6a2e
callq 0x42a0
movq 0x10(%r14), %rdi
leaq 0xa981(%rip), %rsi      # 0x113ba
callq 0x4340
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x6a6b
movq 0x10(%r14), %rdi
callq 0xf5b7
movq %rax, 0x30(%r14)
movq $0x0, 0x38(%r14)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x4150
movq %rax, %rbx
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x63a2
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xa955(%rip), %rsi      # 0x113f8
leaq 0xa964(%rip), %rdx      # 0x1140e
leaq -0x68(%rbp), %rdi
callq 0x6440
movb $0x1, %r12b
leaq 0xa952(%rip), %rcx      # 0x1140f
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x7538
xorl %r12d, %r12d
leaq 0x10f6e(%rip), %rsi     # 0x17a48
leaq 0x155f(%rip), %rdx      # 0x8040
movq %rbx, %rdi
callq 0x44c0
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x6afa
callq 0x4280
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x6b08
callq 0x4280
testb %r12b, %r12b
jne 0x6b25
jmp 0x6b2d
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x6b25
callq 0x4280
jmp 0x6b25
movq %rax, %r14
movq %rbx, %rdi
callq 0x41f0
movq %r14, %rdi
callq 0x44f0
nop