LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15d
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, -0x38(%rbp)
movl %r8d, -0x2c(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x842d(%rip), %rdx      # 0xb207
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x8c74
movl %r13d, 0x20(%rbx)
movslq -0x2c(%rbp), %r8
movl %r8d, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq (%r14), %rax
movq (%r12), %rdi
movl %r8d, %ecx
subl %r15d, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
cmpb (%rdi,%r8), %dl
jne 0x2e5b
movq 0x8(%r12), %rdx
movslq %r15d, %r9
movq %rdx, %rsi
subq %r9, %rsi
subq %r8, %rdx
addq %r8, %rdi
incq %rdi
movq %r8, %rcx
subq %r9, %rcx
incl %r8d
subq $0x1, %rdx
jb 0x2e58
movl %r8d, -0x2c(%rbp)
movb 0x1(%rax,%rcx), %r9b
leaq 0x1(%rdi), %r10
incq %rcx
incl %r8d
cmpb (%rdi), %r9b
movq %r10, %rdi
je 0x2e35
jmp 0x2e5b
movq %rsi, %rcx
cmpq %rcx, 0x8(%r14)
movq -0x38(%rbp), %rbx
jne 0x2e71
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
callq 0x8d70
leaq 0x838f(%rip), %rcx      # 0xb207
leaq -0x70(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
movq %rbx, %rdi
callq 0x6dee
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x2e96
callq 0x6ff2
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x2eaf
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 0x678c
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7abc(%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 0x7aa9(%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 0x7a82(%rip), %rsi      # 0xb0f9
movl $0x9, %edx
movq %rax, %rdi
callq 0x21e0
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x369d
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 0x853e
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 0x3739
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3752
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21c0
movq 0xb85f(%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 0x37a3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x37a3
movq %rax, %rbx
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37d9
movq -0x78(%rbp), %rsi
jmp 0x37cc
jmp 0x37d6
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37d9
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x37d9
movq %rax, %rbx
movq 0xb7d8(%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_O1/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 0x853e
leaq -0x150(%rbp), %rdi
movq %r14, %rsi
callq 0x3172
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x5527
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21c0
leaq -0x130(%rbp), %r14
cmpq $0x0, -0x18(%r14)
je 0x55bc
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 0x8306
cmpb $0x1, -0x88(%rbp)
jne 0x5586
leaq -0xb8(%rbp), %rdi
movb $0x0, 0x30(%rdi)
callq 0x727c
cmpb $0x1, -0xc0(%rbp)
jne 0x559f
leaq -0xd8(%rbp), %rdi
movb $0x0, 0x18(%rdi)
callq 0x6896
cmpb $0x1, -0xf8(%rbp)
jne 0x5673
leaq -0x108(%rbp), %rax
movb $0x0, 0x10(%rax)
jmp 0x565b
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x693c
leaq -0x118(%rbp), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x3ed8
leaq -0x50(%rbp), %rdi
callq 0x67c8
leaq -0xf0(%rbp), %rsi
leaq -0x118(%rbp), %rdx
movq %rbx, %rdi
callq 0x8362
cmpb $0x1, -0x60(%rbp)
jne 0x560f
leaq -0x90(%rbp), %rdi
movb $0x0, 0x30(%rdi)
callq 0x727c
cmpb $0x1, -0x98(%rbp)
jne 0x5628
leaq -0xb0(%rbp), %rdi
movb $0x0, 0x18(%rdi)
callq 0x6896
cmpb $0x1, -0xd0(%rbp)
jne 0x5654
leaq -0xe0(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5654
movq -0xe0(%rbp), %rsi
incq %rsi
callq 0x21c0
leaq -0x108(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5673
movq -0x108(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x67c8
leaq -0x140(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x569a
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 0x6a1c
jmp 0x56de
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x67c8
jmp 0x56de
movq %rax, %rbx
jmp 0x56de
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0x6b20
leaq -0x150(%rbp), %rdi
callq 0x6c1c
jmp 0x5704
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x5704
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1695(%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 0x2066
movq 0x3505(%rip), %rdi      # 0x4fd8
leaq 0x15ca(%rip), %rsi      # 0x30a4
movl $0x7, %edx
callq 0x1140
movq 0x10(%rsp), %rsi
subq 0x8(%rsp), %rsi
sarq $0x2, %rsi
movq 0x34df(%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 0x1cda
movq 0x10(%rsp), %rax
subq 0x8(%rsp), %rax
shrq $0x2, %rax
decl %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
movq 0x20(%rsp), %rdi
movq %rcx, %rdx
negq %rdx
movq $-0x1, %rsi
leaq (%rdx,%rsi), %r8
cmpq $-0x1, %r8
je 0x1b7f
movl 0x8(%rdi,%rsi,4), %r8d
leaq 0x1(%rsi), %rbx
cmpl 0x4(%rdi,%rsi,4), %r8d
movq %rbx, %rsi
jge 0x1b60
jmp 0x1b82
movq %rcx, %rbx
movslq %eax, %r14
testq %rdi, %rdi
je 0x1b8f
callq 0x1100
xorl %edx, %edx
cmpq %r14, %rbx
setl %dl
leaq 0x1518(%rip), %rax      # 0x30b6
leaq 0x1507(%rip), %rsi      # 0x30ac
cmovlq %rax, %rsi
addq $0x9, %rdx
movq 0x3424(%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 0x33fe(%rip), %rdi      # 0x4fd8
callq 0x1030
movq %rax, %rdi
callq 0x10a0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1bf6
callq 0x1100
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c13
callq 0x1100
movq %rbx, %rdi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O1/kkloberdanz[P]Sort/main.cpp
// Function: main
int main() {
    //testIsSorted();
    test();
    timeAnalysis();
    return 0;
}

// Assembly:
pushq %rax
callq 0x17ce
callq 0x130c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12e6(%rip), %rsi      # 0x3055
movq %rdx, %rdi
callq 0x1050
testl %eax, %eax
je 0x1d98
leaq 0x1318(%rip), %rsi      # 0x309a
movq %r15, %rdi
callq 0x1050
testl %eax, %eax
jne 0x1dd6
movq %r14, %rdi
callq 0x22c4
jmp 0x1daf
movq 0x8(%r14), %rdx
subq (%r14), %rdx
shrq $0x2, %rdx
decl %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x21d7
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_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1cda
movslq %ebp, %rax
movq (%r15), %rdi
cmpl %eax, %ebx
movl %ebp, %ecx
cmovgl %ebx, %ecx
movslq %ecx, %rcx
decq %rax
movq %rcx, %rdx
negq %rdx
leaq (%rdx,%rax), %rsi
cmpq $-0x1, %rsi
je 0x2230
movl 0x8(%rdi,%rax,4), %esi
leaq 0x1(%rax), %r15
cmpl 0x4(%rdi,%rax,4), %esi
movq %r15, %rax
jge 0x2213
jmp 0x2233
movq %rcx, %r15
movslq %ebx, %r12
testq %rdi, %rdi
je 0x2240
callq 0x1100
cmpq %r12, %r15
jge 0x22b7
movl %ebx, %eax
subl %ebp, %eax
setle %cl
cmpl $0x64, %eax
setge %al
orb %cl, %al
jne 0x2286
movq (%r14), %rax
movl %ebp, %ecx
testl %ecx, %ecx
jle 0x2280
movl %ecx, %edx
movl %edx, %esi
decl %edx
movl (%rax,%rdx,4), %edi
movl (%rax,%rsi,4), %r8d
cmpl %r8d, %edi
jle 0x2280
movl %edi, (%rax,%rsi,4)
movl %r8d, (%rax,%rdx,4)
leal 0x1(%rdx), %esi
cmpl $0x1, %esi
jg 0x2261
incl %ecx
cmpl %ebx, %ecx
jne 0x225b
cmpl %ebp, %ebx
jle 0x22b7
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x2309
movl %eax, %r15d
leal -0x1(%r15), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x21d7
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x21d7
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2308
movl $0x1, %edx
movl %edx, %esi
testl %edx, %edx
je 0x2301
movl %esi, %edi
decl %esi
movl (%rax,%rsi,4), %r8d
movl (%rax,%rdi,4), %r9d
cmpl %r9d, %r8d
jle 0x2301
movl %r8d, (%rax,%rdi,4)
movl %r9d, (%rax,%rsi,4)
testq %rsi, %rsi
jne 0x22e3
incl %edx
cmpq %rdx, %rcx
ja 0x22dd
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl %ecx, %esi
jge 0x2a0c
movsd (%rdx,%rcx,8), %xmm0
movslq %esi, %rax
movsd (%rdx,%rax,8), %xmm1
ucomisd %xmm1, %xmm0
jb 0x2a04
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 0x29dd
movslq %esi, %rax
movsd (%rdx,%rcx,8), %xmm0
movsd (%rdx,%rax,8), %xmm1
movsd %xmm0, (%rdx,%rax,8)
cvttpd2dq %xmm1, %xmm0
cvtdq2pd %xmm0, %xmm0
movlps %xmm0, (%rdx,%rcx,8)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x29ca
movq (%rdi), %rax
leal 0x1(%rsi), %ecx
testl %esi, %esi
jle 0x29c2
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 0x29c2
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 0x298d
incl %esi
incl %ecx
cmpl %edx, %esi
jne 0x2981
retq
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/test/test_stl.cc
// Function: main
int main(int argc, char **argv){
	if (argc <= 2){
		printUsage(argv[0]);
		return 1;
	}

	const char *filename	= argv[1];
	const char *key		= argv[2];

	MySet list;

	op_search(list, filename, key);

	return 0;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
cmpl $0x2, %edi
jg 0x23d7
movq (%rsi), %rbx
leaq 0x1d3a(%rip), %rdi      # 0x40ea
callq 0x21e0
leaq 0x1c48(%rip), %rdi      # 0x4004
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
movl $0xa, %edi
callq 0x21a0
movl $0x1, %ebx
jmp 0x240f
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
leaq 0x8(%rsp), %rcx
movl $0x0, (%rcx)
xorl %ebx, %ebx
movq %rbx, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rbx, 0x20(%rcx)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x242a
movq %rsp, %rdi
callq 0x24d4
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x24d4
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/test/test_stl.cc
// Function: int op_search<std::set<hm3::Pair, pcomp, std::allocator<hm3::Pair>>>(std::set<hm3::Pair, pcomp, std::allocator<hm3::Pair>>&, char const*, char const*)
int op_search(LIST &list, const char *filename, const char *key){
	FileReader reader{ filename };

	printf("Load start...\n");
	listLoad(list, reader);
	printf("Load done...\n");
	getchar();

#if 0
	printf("Search start...\n");
	listSearch(list, key);
	printf("Search done...\n");
	getchar();
#endif

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2449
movq %rsi, %r14
movq %rsi, %rdi
callq 0x2090
jmp 0x2452
leaq 0x1c4e(%rip), %r14      # 0x409e
xorl %eax, %eax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, 0x8(%rsi)
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movl $0x3, %edx
callq 0x252c
leaq 0x1c7a(%rip), %rdi      # 0x40f1
callq 0x21e0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x25bc
leaq 0x1c6c(%rip), %rdi      # 0x40ff
callq 0x21e0
callq 0x2190
leaq 0x18(%rsp), %rdi
callq 0x2060
xorl %eax, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/test/test_stl.cc
// Function: void listLoad<std::set<hm3::Pair, pcomp, std::allocator<hm3::Pair>>, FileReader>(std::set<hm3::Pair, pcomp, std::allocator<hm3::Pair>>&, FileReader&, bool)
void listLoad(LIST &list, READER &reader, bool const tombstones){
	const std::string empty;

	unsigned int i = 0;

	while(reader){
		std::string line = reader.getLine();

		const std::string &key = line;
		const std::string &val = tombstones ? empty : key;

		list.insert( Pair{ key, val } );

		++i;

		if (i % PROCESS_STEP == 0){
			printf("Processed %10u records, %10zu bytes...\n", i, list.size() );
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, 0xc(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rsi), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rsi,%rax)
jne 0x26de
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %ebp
leaq 0x10(%rsp), %r12
leaq 0x50(%rsp), %r13
movq %r12, %rdi
movq %r14, %rsi
callq 0x27f0
movq 0x18(%rsp), %rax
movq %rax, 0x68(%rsp)
cmpb $0x0, 0xc(%rsp)
cmovneq 0x38(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x70(%rsp)
movq %rax, 0x58(%rsp)
movq %r12, %rax
leaq 0x30(%rsp), %rcx
cmovneq %rcx, %rax
movq (%rax), %rax
movq %rax, 0x60(%rsp)
movq %r13, %rdi
leaq 0x68(%rsp), %rsi
leaq 0x58(%rsp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2ad0
movq %r15, %rdi
movq %r13, %rsi
callq 0x28d8
movl %ebp, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
imulq %rcx, %rax
shrq $0x2d, %rax
imull $0x2710, %eax, %eax     # imm = 0x2710
movl $0x1, %ebx
subl %eax, %ebx
movq %r13, %rdi
callq 0x2a84
addl %ebp, %ebx
cmpl $0x1, %ebx
jne 0x26ad
movq 0x28(%r15), %rdx
leaq 0x19ce(%rip), %rdi      # 0x4072
movl %ebp, %esi
xorl %eax, %eax
callq 0x2030
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x26c9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2150
movq (%r14), %rax
movq -0x18(%rax), %rax
incl %ebp
cmpl $0x0, 0x20(%r14,%rax)
je 0x2609
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x26fa
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2150
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x273c
movq %rax, %rbx
jmp 0x2720
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2a84
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x273c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2150
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x2758
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/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, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
cmpq %rax, %rdx
je 0x2a6c
movl $0x1, %r12d
xorl %ecx, %ecx
movq (%rax,%rcx,8), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2b36
movq %r15, %rdi
callq 0x417c
movl %r12d, %ecx
movq (%r14), %rax
movq 0x8(%r14), %rdx
movq %rdx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
incl %r12d
cmpq %rcx, %rsi
ja 0x2a37
cmpq %rax, %rdx
je 0x2a75
movq %rax, 0x8(%r14)
movq 0x18(%rbx), %rsi
cmpq %rsi, 0x20(%rbx)
je 0x2b10
xorl %r15d, %r15d
leaq (%r15,%r15,2), %rax
leaq (%rsi,%rax,8), %r13
movq (%r13), %rax
movq 0x8(%r13), %rcx
cmpq %rax, %rcx
je 0x2ade
movl $0x1, %r12d
xorl %edx, %edx
movq (%rax,%rdx,8), %r14
testq %r14, %r14
je 0x2ac1
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2b36
movq %r14, %rdi
callq 0x417c
movl %r12d, %edx
movq (%r13), %rax
movq 0x8(%r13), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
incl %r12d
cmpq %rdx, %rsi
ja 0x2aa3
cmpq %rax, %rcx
je 0x2ae7
movq %rax, 0x8(%r13)
incl %r15d
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rax
subq %rsi, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %r15, %rax
ja 0x2a86
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x2e9c
movq 0x54ad(%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_O1/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 0x2b7e
cmpl $0x2, %edx
je 0x2b5d
cmpl $0x1, %edx
jne 0x2b80
movl (%rsi), %esi
movq 0x547f(%rip), %rdi      # 0x7fd0
callq 0x20f0
leaq 0x6(%rsp), %rsi
jmp 0x2b6e
movq 0x546c(%rip), %rdi      # 0x7fd0
callq 0x4181
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x21e0
popq %rax
retq
movq 0x5449(%rip), %rdi      # 0x7fd0
leaq 0x2578(%rip), %rsi      # 0x5106
callq 0x2190
leaq 0x24b2(%rip), %rdi      # 0x504c
leaq 0x24ad(%rip), %rsi      # 0x504e
leaq 0x2564(%rip), %rcx      # 0x510c
movl $0xf5, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/olegstrelnikov[P]thread-pool/test/main.cpp
// Function: void f<1ul>()
void f() {
	static_assert(N > 0, "");
	static_assert(N <= FUNCTIONS, "");
	++calls[N - 1];
	thread_ids[N - 1] = std::this_thread::get_id();
	std::this_thread::sleep_for(std::chrono::microseconds(1));
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
incq 0x38ea(%rip)            # 0x6160
callq 0x2140
movq %rax, 0x395e(%rip)      # 0x61e0
movq %rsp, %rbx
movq $0x0, (%rbx)
movq $0x3e8, 0x8(%rbx)       # imm = 0x3E8
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x2080
cmpl $-0x1, %eax
jne 0x28ae
callq 0x2030
cmpl $0x4, (%rax)
je 0x2894
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fb8
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 0x2fec
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rdi), %rbp
leaq 0x60(%rdi), %rax
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
leaq 0x18(%rsp), %r15
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq %r15, %rdi
callq 0x326e
movb $0x1, 0x20(%rsp)
movq (%rbp), %r12
cmpq %rbp, %r12
je 0x2f56
movq 0x10(%r12), %r13
decq 0x18(%rbx)
movq %r12, %rdi
callq 0x21e0
movq %r12, %rdi
callq 0x2160
xorl %r12d, %r12d
jmp 0x2f77
movl $0x3, %r12d
cmpb $0x1, (%rbx)
jne 0x2f74
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x2070
movl $0x2, %r12d
movq %r14, %r13
movq %r15, %rdi
callq 0x3258
testl %r12d, %r12d
je 0x2f8f
movq %r13, %r14
cmpl $0x2, %r12d
je 0x2f13
jmp 0x2fa9
movl $0x0, %r14d
testq %r13, %r13
je 0x2f13
callq *%r13
xorl %r14d, %r14d
jmp 0x2f13
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/CoderUper[P]BTree/main.cpp
// Function: main
int main()
{
    BTree bt;
    std::cout<<sizeof(Node)<<"B"<<std::endl;
    keyType keys[]={17 ,113 ,58 ,10 ,23 ,191 ,34 ,73 ,84 ,34 ,85 ,178 ,154 ,165 ,193 ,170 ,125 ,18 };
    int count=int(sizeof(keys)/sizeof(keyType));
    for(int i=0;i<count;i++)
        bt.insert(keys[i]);
    keyType n=1;
    srand((int)time(0));
    while(n<=1000)
    {
        int e=random(200)+1;
        bt.insert(e);
        key_list.push_back(e);
        n++;
    }
    std::cout<<"key num is "<<bt.get_num()<<std::endl;
    bt.bfs_print();
//    bt.remove(58);
/*
    for(int i=0;i<count;i++){
        bt.remove(keys[i]);  
    }
    bt.bfs_print();
    */
    /*
    for(std::vector<keyType>::iterator it=key_list.begin();it!=key_list.end();it++)
    {
        std::cout<<*it<<" ";
    }*/
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x16c4
movq 0x3c05(%rip), %rdi      # 0x4fd8
movl $0x80, %esi
callq 0x10b0
movq %rax, %rbx
leaq 0x1c1d(%rip), %rsi      # 0x3004
movl $0x1, %edx
movq %rax, %rdi
callq 0x1170
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10c0
xorl %r14d, %r14d
leaq 0x1c0b(%rip), %r15      # 0x3030
leaq -0x40(%rbp), %rbx
movq (%r14,%r15), %rsi
movq %rbx, %rdi
callq 0x1882
addq $0x8, %r14
cmpq $0x90, %r14
jne 0x1429
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x1120
movl $0x3e8, %r13d           # imm = 0x3E8
leaq -0x40(%rbp), %rbx
leaq 0x3ca7(%rip), %r14      # 0x5108
leaq -0x48(%rbp), %r15
callq 0x1050
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rcx
addl %edx, %ecx
imull $0xc8, %ecx, %ecx
negl %ecx
addl %ecx, %eax
incl %eax
movslq %eax, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1882
movq %r12, -0x48(%rbp)
movq 0x3c6b(%rip), %rsi      # 0x5110
cmpq 0x3c6c(%rip), %rsi      # 0x5118
je 0x14be
movq %r12, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x3c54(%rip)      # 0x5110
jmp 0x14c9
movq %r14, %rdi
movq %r15, %rdx
callq 0x1584
decq %r13
jne 0x1465
movq 0x3b03(%rip), %rdi      # 0x4fd8
leaq 0x1b2a(%rip), %rsi      # 0x3006
movl $0xb, %edx
callq 0x1170
leaq -0x40(%rbp), %rdi
callq 0x22c4
movq 0x3ae2(%rip), %rdi      # 0x4fd8
movl %eax, %esi
callq 0x11a0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10c0
leaq -0x40(%rbp), %rdi
callq 0x20f4
leaq -0x40(%rbp), %rdi
callq 0x1782
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1552
jmp 0x1552
jmp 0x1552
jmp 0x1552
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x1782
movq %rbx, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/CoderUper[P]BTree/BTree.cpp
// Function: BTree::create_node()
Node* BTree::create_node()
{
    Node* node=new Node();
    if(node==NULL)
    {
        std::cout<<"memory allocation error\n";
        exit(1);
    }
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x80, %edi
callq 0x1140
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x68(%rax)
xorl %ecx, %ecx
movq %rcx, 0x70(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movq %rcx, 0x60(%rax)
movb $0x1, 0x78(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/CoderUper[P]BTree/BTree.cpp
// Function: BTree::~BTree()
BTree::~BTree()
{
    if(root)
        release(root);
    root=NULL;
    std::cout<<"\na BTree is destroyed!\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x179b
movq %rbx, %rdi
callq 0x17ca
movq $0x0, (%rbx)
movq 0x382f(%rip), %rdi      # 0x4fd8
leaq 0x1925(%rip), %rsi      # 0x30d5
movl $0x17, %edx
callq 0x1170
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x22d8
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x181e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x0, 0x6c(%rsi)
jle 0x1807
movq %rdi, %r14
xorl %r15d, %r15d
cmpb $0x0, 0x78(%rbx)
jne 0x17fb
movq 0x30(%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x17ca
incq %r15
movslq 0x6c(%rbx), %rax
cmpq %rax, %r15
jl 0x17e8
movl $0x80, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1150
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x187e
movl 0x68(%rcx), %edx
testl %edx, %edx
jle 0x1849
xorl %r8d, %r8d
cmpq %rsi, (%rcx,%r8,8)
jg 0x1846
incq %r8
cmpq %r8, %rdx
jne 0x1836
jmp 0x1849
movl %r8d, %edx
testl %edx, %edx
jle 0x185e
leal -0x1(%rdx), %r8d
cmpq %rsi, (%rcx,%r8,8)
jne 0x185e
xorl %edx, %edx
movq %rcx, %rax
jmp 0x1878
movq %rcx, 0x10(%rdi)
cmpb $0x0, 0x78(%rcx)
je 0x186e
xorl %eax, %eax
xorl %edx, %edx
jmp 0x1878
movslq %edx, %rdx
movq 0x30(%rcx,%rdx,8), %rcx
movb $0x1, %dl
testb %dl, %dl
jne 0x1827
jmp 0x1880
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1820
movq %rax, %r14
testq %rax, %rax
jne 0x1923
movq 0x10(%rbx), %rsi
movslq 0x68(%rsi), %rcx
movl %ecx, %eax
testq %rcx, %rcx
jle 0x18c2
xorl %edi, %edi
cmpq %r15, (%rsi,%rdi,8)
jg 0x18c4
incq %rdi
cmpq %rdi, %rax
jne 0x18b4
movl %eax, %edi
movslq %edi, %rdx
cmpl %edi, %eax
jle 0x18e0
movq -0x8(%rsi,%rcx,8), %rdi
movq %rdi, (%rsi,%rcx,8)
leaq -0x1(%rcx), %rdi
movq %rdi, %rcx
cmpq %rdx, %rdi
jg 0x18cb
movq %r15, (%rsi,%rdx,8)
incl %eax
movl %eax, 0x68(%rsi)
movslq 0x6c(%rsi), %rax
cmpl %edx, %eax
jle 0x190a
movq %rax, %rcx
movq 0x28(%rsi,%rcx,8), %rdi
movq %rdi, 0x30(%rsi,%rcx,8)
leaq -0x1(%rcx), %rdi
movq %rdi, %rcx
cmpq %rdx, %rdi
jg 0x18f4
movq $0x0, 0x30(%rsi,%rdx,8)
incl %eax
movl %eax, 0x6c(%rsi)
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0x1934
testq %r14, %r14
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1820
movq %rax, %r14
testq %rax, %rax
je 0x1cd2
movl 0x68(%r14), %eax
testl %eax, %eax
jle 0x1c76
xorl %ecx, %ecx
cmpq %r15, (%r14,%rcx,8)
jg 0x1c74
incq %rcx
cmpq %rcx, %rax
jne 0x1c64
jmp 0x1c76
movl %ecx, %eax
leal -0x1(%rax), %r15d
cmpb $0x0, 0x78(%r14)
je 0x1c86
movq %r14, %r12
jmp 0x1cae
cltq
leaq (%r14,%rax,8), %rax
addq $0x30, %rax
movq (%rax), %r12
leaq 0x30(%r12), %rax
cmpb $0x1, 0x78(%r12)
jne 0x1c90
movq (%r12), %rax
movslq %r15d, %rcx
movq %rax, (%r14,%rcx,8)
xorl %r15d, %r15d
movq %r12, %rdi
movl %r15d, %esi
callq 0x22e6
movq %r12, %rdi
movl %r15d, %esi
callq 0x2338
decl 0x8(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1ce2
testq %r14, %r14
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x231b
movl 0x68(%rdi), %ecx
cmpl %esi, %ecx
jle 0x231b
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 0x2303
decl %ecx
movl %ecx, 0x68(%rdi)
jmp 0x2335
movq 0x2cb6(%rip), %rdi      # 0x4fd8
leaq 0xdf6(%rip), %rsi       # 0x311f
movl $0x10, %edx
callq 0x1170
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x236d
movl 0x6c(%rdi), %ecx
cmpl %esi, %ecx
jle 0x236d
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 0x2355
decl %ecx
movl %ecx, 0x6c(%rdi)
jmp 0x2387
movq 0x2c64(%rip), %rdi      # 0x4fd8
leaq 0xdb5(%rip), %rsi       # 0x3130
movl $0x12, %edx
callq 0x1170
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ParkerLab[P]cta/src/cta.cpp
// Function: operator<<(std::ostream&, FASTQRecord const&)
std::ostream& operator<<(std::ostream& os, const FASTQRecord& record) {
    os << record.name << '\n'
       << record.sequence << '\n'
       << record.comment << '\n'
       << record.quality << '\n';
    return os;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0xb540
movb $0xa, %bpl
leaq 0xc(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xb540
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
movq %rax, %rdi
callq 0xb540
leaq 0xd(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xb540
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rax, %rdi
callq 0xb540
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xb540
movq 0x60(%r14), %rsi
movq 0x68(%r14), %rdx
movq %rax, %rdi
callq 0xb540
leaq 0xf(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xb540
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ParkerLab[P]cta/src/cta.cpp
// Function: operator>>(std::istream&, FASTQRecord&)
std::istream& operator>>(std::istream& is, FASTQRecord& record) {
    getline(is, record.name);
    getline(is, record.sequence);
    getline(is, record.comment);
    getline(is, record.quality);
    return is;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb440
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb830
leaq 0x40(%r14), %r15
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb440
movsbl %al, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb830
leaq 0x20(%r14), %r15
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb440
movsbl %al, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb830
addq $0x60, %r14
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb440
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb830
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d3de(%rip), %rsi     # 0x29148
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 0x1d387(%rip), %rsi     # 0x2914b
leaq 0x40(%rsp), %rdi
movq %r14, %rdx
callq 0xefbc
leaq 0x1d389(%rip), %rsi     # 0x29161
leaq 0x40(%rsp), %rdi
callq 0xb880
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xbe03
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0xbe0f
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %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 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xbe63
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xbe70
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%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 0x2efca(%rip), %rax     # 0x3ae68
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x2ef96(%rip), %rsi     # 0x3ae40
movq 0x310bf(%rip), %rdx     # 0x3cf70
movq %rbx, %rdi
callq 0xb7b0
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xbedb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb480
jmp 0xbedb
movq %rax, %r14
movb $0x1, %bpl
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xbef9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb480
jmp 0xbef9
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbf1c
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xb480
jmp 0xbf1c
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xbf29
movq %rbx, %rdi
callq 0xb380
movq %r14, %rdi
callq 0xb7d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc0b3
movq (%rsi), %rbp
xorl %r12d, %r12d
leaq 0x31971(%rip), %r14     # 0x3d9f8
leaq 0xf(%rsp), %r15
movb (%rbp,%r12), %al
movb %al, 0xf(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xf192
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0xb3e0
incq %r12
cmpq %r12, %r13
jne 0xc08c
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 0xc0e2
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0xb480
movq %r14, %rdi
callq 0xb7d0
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x20(%rsp)
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
movq %rsp, %r13
leaq 0x30(%rsp), %rbp
leaq 0x28(%rsp), %rbx
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
movq %rbx, %rdx
callq 0x1f074
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xc1cb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb480
movq 0x8(%r15), %rax
subq %r14, %rax
cmpq %r12, %rax
ja 0xc189
movb $0x1, %bpl
movq $-0x1, %r15
movq %rsp, %r12
leaq 0x30(%rsp), %r13
movq 0x20(%rsp), %rsi
incq %r15
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0xb4c0
movq %r13, %rdi
movq %r12, %rsi
callq 0x1f476
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xc228
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb480
testq %rbx, %rbx
movq 0x20(%rsp), %rsi
jne 0xc242
movq 0x8(%rsi), %rax
subq %r14, %rax
cmpq %r15, %rax
seta %bpl
ja 0xc1ee
leaq 0x30(%rsp), %rdi
callq 0xfd5e
andb $0x1, %bpl
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc265
jmp 0xc26a
movq %rax, %rbx
jmp 0xc288
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xc288
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb480
leaq 0x30(%rsp), %rdi
callq 0xfd5e
movq %rbx, %rdi
callq 0xb7d0