LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x1f8(%rbp), %r12
movq %r12, %rdi
callq 0x31c0
leaq 0x50f3(%rip), %rsi      # 0x90dc
movq %r12, %rdi
callq 0x3180
movq %rax, %rdi
movq %r14, %rsi
callq 0x3170
leaq 0x50ec(%rip), %rsi      # 0x90ef
movq %rax, %rdi
callq 0x3180
movq %rax, %r12
movl 0x20(%r14), %esi
leaq -0x80(%rbp), %rdi
callq 0x33ac
leaq -0x80(%rbp), %rsi
movq %r12, %rdi
callq 0x3170
leaq 0x50cb(%rip), %rsi      # 0x90f9
movq %rax, %rdi
callq 0x3180
leaq -0x80(%rbp), %rdi
callq 0x585c
leaq -0x1f8(%rbp), %rdi
callq 0x30c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x3170
leaq -0x1f0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x3130
movq 0x28(%r14), %rsi
leaq -0x40(%rbp), %rdi
callq 0x5890
movl 0x24(%r14), %ecx
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x3418
leaq -0x40(%rbp), %rdi
callq 0x585c
leaq -0x60(%rbp), %rdi
callq 0x585c
leaq -0x1f8(%rbp), %rdi
callq 0x3060
movq %rbx, %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x585c
jmp 0x40c9
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x40d8
jmp 0x40df
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x585c
jmp 0x40e2
movq %rax, %rbx
leaq -0x1f8(%rbp), %rdi
callq 0x3060
movq %rbx, %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdi, %rbx
leaq -0x80(%rbp), %r14
movq %r14, %rdi
callq 0x5890
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x3cc5
leaq -0x80(%rbp), %rdi
callq 0x585c
cmpq $0x0, -0x58(%rbp)
je 0x5140
xorl %eax, %eax
leaq -0x148(%rbp), %rsi
movb %al, 0x20(%rsi)
movb %al, 0x30(%rsi)
movb %al, 0x39(%rsi)
movb %al, 0x58(%rsi)
movb %al, 0x90(%rsi)
andl $0x0, 0x98(%rsi)
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x705c
leaq -0x148(%rbp), %rdi
callq 0x5b9e
jmp 0x518a
leaq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x59f6
leaq -0x148(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x44df
leaq -0x28(%rbp), %rdi
callq 0x58ce
leaq -0x120(%rbp), %rsi
leaq -0x148(%rbp), %rdx
movq %rbx, %rdi
callq 0x7096
leaq -0x148(%rbp), %rdi
callq 0x5a8e
leaq -0x60(%rbp), %rdi
callq 0x5c08
movq %rbx, %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x148(%rbp), %rdi
callq 0x5a8e
jmp 0x51d5
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x58ce
jmp 0x51d5
movq %rax, %rbx
jmp 0x51d5
movq %rax, %rbx
leaq -0x148(%rbp), %rdi
callq 0x5b9e
leaq -0x60(%rbp), %rdi
callq 0x5c08
jmp 0x51ec
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x585c
movq %rbx, %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/eatonphil[P]cpp-json/main.cpp
// Function: main
int main(int argc, char *argv[]) {
  if (argc == 1) {
    std::cerr << "Expected JSON input argument to parse" << std::endl;
    return 1;
  }

  std::string in{argv[1]};

  auto [ast, error] = json::parse(in);
  if (error.size()) {
    std::cerr << error << std::endl;
    return 1;
  }

  std::cout << json::deparse(ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
cmpl $0x1, %edi
jne 0x88cc
movq 0x5740(%rip), %rdi      # 0xdff0
leaq 0xb6a(%rip), %rsi       # 0x9421
callq 0x3180
movq %rax, %rdi
callq 0x30c0
pushq $0x1
popq %rbx
jmp 0x89b8
movq 0x8(%rsi), %rsi
leaq -0x90(%rbp), %rbx
leaq -0x150(%rbp), %rdx
movq %rbx, %rdi
callq 0x5820
leaq -0x70(%rbp), %rdi
movq %rbx, %rsi
callq 0x5890
leaq -0x150(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x50cb
leaq -0x70(%rbp), %rdi
callq 0x585c
cmpq $0x0, -0x148(%rbp)
je 0x8935
movq 0x56d4(%rip), %rdi      # 0xdff0
leaq -0x150(%rbp), %rsi
callq 0x3170
movq %rax, %rdi
callq 0x30c0
pushq $0x1
popq %rbx
jmp 0x89a0
leaq -0x130(%rbp), %rsi
leaq -0x1f0(%rbp), %rdi
callq 0x5d8c
leaq 0x8b8(%rip), %rsi       # 0x9207
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x5820
leaq -0x50(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x51f4
movq 0x5651(%rip), %rdi      # 0xdfc8
leaq -0x50(%rbp), %rsi
callq 0x3170
leaq -0x50(%rbp), %rdi
callq 0x585c
leaq -0x30(%rbp), %rdi
callq 0x585c
leaq -0x1f0(%rbp), %rdi
callq 0x5b9e
xorl %ebx, %ebx
leaq -0x150(%rbp), %rdi
callq 0x8a2a
leaq -0x90(%rbp), %rdi
callq 0x585c
movl %ebx, %eax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x585c
jmp 0x89d5
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x585c
jmp 0x89e3
movq %rax, %rbx
leaq -0x1f0(%rbp), %rdi
callq 0x5b9e
jmp 0x8a09
jmp 0x8a06
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x585c
jmp 0x8a15
movq %rax, %rbx
jmp 0x8a15
movq %rax, %rbx
leaq -0x150(%rbp), %rdi
callq 0x8a2a
leaq -0x90(%rbp), %rdi
callq 0x585c
movq %rbx, %rdi
callq 0x3260
nop
// File: /workspace/github_cpp_makefile_star2_O2/kkloberdanz[P]Sort/main.cpp
// Function: test()
void test() {
    srand(time(0));
    std::vector<double> V;
    std::vector<double> Vcopy;
    std::vector<double> sortedVector;

    const int VECTOR_SIZE = 100;

    for (int i = 0; i < VECTOR_SIZE; i++) {
        V.push_back(rand() % 100);
    }

    std::cout << "unsorted\n";
    printVector(V);

    std::cout << "quick\n";
    printVector(kgk::sort(V, "quick"));

    std::cout << "insertion\n";
    printVector(kgk::sort(V, "insertion"));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
xorl %edi, %edi
callq 0x10f0
movl %eax, %edi
callq 0x1110
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
andq $0x0, 0x10(%rbx)
movapd %xmm0, (%rbx)
andq $0x0, 0x60(%rsp)
movapd %xmm0, 0x50(%rsp)
andq $0x0, 0x40(%rsp)
movapd %xmm0, 0x30(%rsp)
pushq $0x64
popq %rbp
leaq 0x8(%rsp), %r14
movl %ebp, %r15d
subl $0x1, %r15d
jb 0x16ad
callq 0x1030
cltd
idivl %ebp
cvtsi2sd %edx, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24c4
jmp 0x1688
movq 0x4924(%rip), %rdi      # 0x5fd8
leaq 0x19ab(%rip), %rsi      # 0x3066
callq 0x1120
leaq 0xd0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1c20
leaq 0xd0(%rsp), %rdi
callq 0x1bbd
leaq 0xd0(%rsp), %rdi
callq 0x24b6
movq 0x48e5(%rip), %rdi      # 0x5fd8
leaq 0x1976(%rip), %rsi      # 0x3070
callq 0x1120
leaq 0xa0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1c20
leaq 0x1925(%rip), %rsi      # 0x303d
leaq 0x108(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1060
leaq 0xb8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x108(%rsp), %rdx
callq 0x1c6d
leaq 0xb8(%rsp), %rdi
callq 0x1bbd
leaq 0xb8(%rsp), %rdi
callq 0x24b6
leaq 0x108(%rsp), %rdi
callq 0x1070
leaq 0xa0(%rsp), %rdi
callq 0x24b6
movq 0x4856(%rip), %rdi      # 0x5fd8
leaq 0x18ee(%rip), %rsi      # 0x3077
callq 0x1120
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1c20
leaq 0x18de(%rip), %rsi      # 0x3082
leaq 0xe8(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1060
leaq 0x88(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0xe8(%rsp), %rdx
callq 0x1c6d
leaq 0x88(%rsp), %rdi
callq 0x1bbd
leaq 0x88(%rsp), %rdi
callq 0x24b6
leaq 0xe8(%rsp), %rdi
callq 0x1070
leaq 0x70(%rsp), %rdi
callq 0x24b6
leaq 0x30(%rsp), %rdi
callq 0x24b6
leaq 0x50(%rsp), %rdi
callq 0x24b6
leaq 0x10(%rsp), %rdi
callq 0x24b6
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x24b6
jmp 0x1842
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0x1070
jmp 0x1854
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x1897
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x24b6
jmp 0x1870
movq %rax, %rbx
leaq 0x108(%rsp), %rdi
callq 0x1070
jmp 0x1882
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
jmp 0x1897
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x24b6
jmp 0x18a3
jmp 0x18a0
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x24b6
leaq 0x50(%rsp), %rdi
callq 0x24b6
leaq 0x10(%rsp), %rdi
callq 0x24b6
movq %rbx, %rdi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
leaq 0x181b(%rip), %rsi      # 0x30f4
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 0x1cee
movq 0x46cf(%rip), %rdi      # 0x5fd8
leaq 0x177c(%rip), %rsi      # 0x308c
callq 0x1120
movq 0x10(%rsp), %rsi
subq 0x8(%rsp), %rsi
sarq $0x2, %rsi
movq %rax, %rdi
callq 0x10b0
movq %rax, %rdi
callq 0x1080
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1a2e
movq 0x10(%rsp), %rdx
subq 0x8(%rsp), %rdx
shrq $0x2, %rdx
decl %edx
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1d24
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1d4a
leaq 0x1722(%rip), %rax      # 0x3094
leaq 0x1725(%rip), %rsi      # 0x309e
testb %bpl, %bpl
cmovneq %rax, %rsi
movq 0x4651(%rip), %rdi      # 0x5fd8
callq 0x1120
movq %rax, %rdi
callq 0x1080
leaq 0x8(%rsp), %rdi
callq 0x1d4a
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1d4a
movq %rbx, %rdi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O2/kkloberdanz[P]Sort/main.cpp
// Function: main
int main() {
    //testIsSorted();
    test();
    timeAnalysis();
    return 0;
}

// Assembly:
pushq %rax
callq 0x1638
callq 0x12dc
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15ad(%rip), %rsi      # 0x303d
movq %rdx, %rdi
callq 0x1ede
testb %al, %al
je 0x1ab5
movq 0x8(%r14), %rdx
subq (%r14), %rdx
shrq $0x2, %rdx
decl %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1eeb
jmp 0x1ad0
leaq 0x15c6(%rip), %rsi      # 0x3082
movq %r15, %rdi
callq 0x1ede
testb %al, %al
je 0x1af4
movq %r14, %rdi
callq 0x1f7d
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x1
popq %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/kkloberdanz[P]Sort/./sort.cpp
// Function: bool kgk::isSorted<int>(std::vector<int, std::allocator<int>>, int, int)
bool isSorted(std::vector<T> v, int low, int high) {
    T prev = v[low];
    //std::cout << "size = " << v.size() << std::endl;
    for (int i = 1+low; i <= high; i++) {
        //std::cout << "i = " << i << std::endl;
        //std::cout << v[i] << " < " << prev << std::endl;
        if (v[i] < prev) {
            return false;
        }
        prev = v[i];
    }
    return true;

}

// Assembly:
movslq %esi, %rsi
movq (%rdi), %rcx
movslq %edx, %rax
movq %rsi, %rdx
cmpq %rax, %rsi
jge 0x1d42
leaq 0x1(%rdx), %rsi
movl 0x4(%rcx,%rdx,4), %edi
cmpl (%rcx,%rdx,4), %edi
jge 0x1d2d
cmpq %rax, %rdx
setge %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1a2e
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1d24
movl %eax, %r12d
movq %r15, %rdi
callq 0x1d4a
testb %r12b, %r12b
jne 0x1f70
movl %ebx, %eax
subl %ebp, %eax
cmpl $0x63, %eax
jg 0x1f3f
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1fc1
cmpl %ebp, %ebx
jle 0x1f70
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1ff3
movl %eax, %r15d
leal -0x1(%r15), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x1eeb
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x1eeb
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdx
movl %edx, %esi
movl %edx, %edi
cmpq %rsi, %rcx
jbe 0x1fc0
movl %edi, %esi
subl $0x1, %esi
jb 0x1fbc
movl %esi, %r8d
movl (%rax,%r8,4), %r9d
movl %edi, %edi
movl (%rax,%rdi,4), %r10d
cmpl %r10d, %r9d
jle 0x1fbc
movl %r9d, (%rax,%rdi,4)
movl %r10d, (%rax,%r8,4)
movl %esi, %edi
jmp 0x1f97
incl %edx
jmp 0x1f8e
retq
// File: /workspace/github_cpp_makefile_star2_O2/kkloberdanz[P]Sort/./sort.cpp
// Function: void kgk::insertionsort<int>(std::vector<int, std::allocator<int>>&, 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 0x1ff2
movq (%rdi), %rax
movl %esi, %ecx
testl %ecx, %ecx
jle 0x1fee
leal -0x1(%rcx), %r8d
movl (%rax,%r8,4), %r9d
movl %ecx, %ecx
movl (%rax,%rcx,4), %r10d
cmpl %r10d, %r9d
jle 0x1fee
movl %r9d, (%rax,%rcx,4)
movl %r10d, (%rax,%r8,4)
movl %r8d, %ecx
jmp 0x1fca
incl %esi
jmp 0x1fc1
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movslq %esi, %rdi
movslq %esi, %rax
cmpq %rcx, %rdi
jge 0x27ce
movsd (%rdx,%rdi,8), %xmm1
ucomisd %xmm1, %xmm0
jb 0x27c9
movsd (%rdx,%rax,8), %xmm2
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
movsd %xmm1, (%rdx,%rax,8)
movlps %xmm2, (%rdx,%rdi,8)
incl %eax
movl %eax, %esi
incq %rdi
jmp 0x279c
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
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23f3
movq (%rsi), %rbx
leaq 0x1ccf(%rip), %rdi      # 0x409f
callq 0x2210
leaq 0x1c28(%rip), %rdi      # 0x4004
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
pushq $0xa
popq %rdi
callq 0x21e0
pushq $0x1
popq %rax
jmp 0x242a
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
leaq 0x8(%rsp), %rcx
andl $0x0, (%rcx)
andq $0x0, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
andq $0x0, 0x20(%rcx)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x2443
movq %rsp, %rdi
callq 0x24d4
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x24d4
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2538
leaq 0x10(%rsp), %r15
pushq $0x3
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2568
leaq 0x1c2f(%rip), %rdi      # 0x40a6
callq 0x2210
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x25bb
leaq 0x1c23(%rip), %rdi      # 0x40b4
callq 0x2210
callq 0x21d0
leaq 0x10(%rsp), %rdi
callq 0x2080
xorl %eax, %eax
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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)
movq %rsi, %r14
movq %rdi, %r15
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
pushq $0x1
popq %rbp
leaq 0x58(%rsp), %r12
leaq 0x10(%rsp), %r13
movl %ebp, %eax
xorl %edx, %edx
movl $0x2710, %ecx           # imm = 0x2710
divl %ecx
movl %eax, %ebx
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
jne 0x26aa
movq %r12, %rdi
movq %r14, %rsi
callq 0x27ba
movq 0x58(%rsp), %rax
movq 0x60(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
cmpb $0x0, 0xc(%rsp)
cmovneq 0x40(%rsp), %rcx
movq %rcx, 0x18(%rsp)
cmovneq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %r13, %rdi
leaq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2aa8
movq %r15, %rdi
movq %r13, %rsi
callq 0x2864
imull $0x2710, %ebx, %eax     # imm = 0x2710
pushq $0x1
popq %rbx
subl %eax, %ebx
movq %r13, %rdi
callq 0x2a88
addl %ebp, %ebx
cmpl $0x1, %ebx
jne 0x269b
movq 0x28(%r15), %rdx
leaq 0x19e0(%rip), %rdi      # 0x4072
movl %ebp, %esi
xorl %eax, %eax
callq 0x2030
movq %r12, %rdi
callq 0x20e0
incl %ebp
jmp 0x25f1
leaq 0x38(%rsp), %rdi
callq 0x20e0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2a88
jmp 0x26d5
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x20e0
jmp 0x26e4
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-cardinality.cc
// Function: google_extremal_sets::AllMaximalSetsCardinality::IndexSets(std::vector<google_extremal_sets::SetProperties*, std::allocator<google_extremal_sets::SetProperties*>> const&)
void AllMaximalSetsCardinality::IndexSets(const std::vector<SetProperties*>& index_us) {
  for (std::vector<SetProperties*>::const_iterator it = index_us.begin();
       it != index_us.end();
       ++it) {
    SetProperties* itemset_to_index = *it;
    uint32_t item_id_to_index = itemset_to_index->item[0];
    if (item_id_to_index >= candidates_.size())
      candidates_.resize(item_id_to_index + 1);
    candidates_[item_id_to_index].push_back(itemset_to_index);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r13
leaq 0x18(%rdi), %r15
movq %rsp, %r12
cmpq 0x8(%rbx), %r13
je 0x28cb
movq (%r13), %rax
movq %rax, (%rsp)
movl 0x8(%rax), %ebp
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %rbp, %rax
ja 0x28b6
leal 0x1(%rbp), %esi
movq %r15, %rdi
callq 0x2a38
movq (%r15), %rcx
imulq $0x18, %rbp, %rdi
addq %rcx, %rdi
movq %r12, %rsi
callq 0x2a6e
addq $0x8, %r13
jmp 0x287f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %eax, %eax
movl %eax, %r13d
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r13, %rdx
jbe 0x2927
movq (%rax,%r13,8), %r12
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x29ca
movq %r12, %rdi
callq 0x3d08
leal 0x1(%r13), %eax
jmp 0x28ef
cmpq %rax, %rcx
je 0x2930
movq %rax, 0x8(%r15)
leaq 0x18(%r14), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
movl %r13d, %r13d
movq 0x18(%r14), %r15
movq 0x20(%r14), %rax
subq %r15, %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq %r13, %rax
jbe 0x29a7
imulq $0x18, %r13, %rax
addq %rax, %r15
xorl %ebp, %ebp
movl %ebp, %ebp
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rbp, %rdx
jbe 0x2999
movq (%rax,%rbp,8), %r12
testq %r12, %r12
je 0x2995
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x29ca
movq %r12, %rdi
callq 0x3d08
incl %ebp
jmp 0x295f
cmpq %rax, %rcx
je 0x29a2
movq %rax, 0x8(%r15)
incl %r13d
jmp 0x293b
movq (%rsp), %rdi
callq 0x2ae2
movq 0x4619(%rip), %rdi      # 0x6fd0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a04
cmpl $0x2, %edx
je 0x29ec
cmpl $0x1, %edx
jne 0x2a06
movl (%rsi), %esi
movq 0x45eb(%rip), %rdi      # 0x6fd0
callq 0x2110
jmp 0x29f8
movq 0x45dd(%rip), %rdi      # 0x6fd0
callq 0x3d0d
pushq $0xa
popq %rsi
movq %rax, %rdi
popq %rax
jmp 0x21f0
popq %rax
retq
movq 0x45c3(%rip), %rdi      # 0x6fd0
leaq 0x16f2(%rip), %rsi      # 0x4106
callq 0x21b0
leaq 0x162c(%rip), %rdi      # 0x404c
leaq 0x1627(%rip), %rsi      # 0x404e
leaq 0x16de(%rip), %rcx      # 0x410c
movl $0xf5, %edx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-cardinality.cc
// Function: google_extremal_sets::AllMaximalSetsCardinality::NextCandidate(std::vector<google_extremal_sets::SetProperties*, std::allocator<google_extremal_sets::SetProperties*>> const&, std::vector<unsigned int, std::allocator<unsigned int>> const&, unsigned int, int*)
inline SetProperties* AllMaximalSetsCardinality::NextCandidate(
    const CandidateList& candidates,
    const std::vector<uint32_t>& current_set,
    unsigned int current_index,
    int* candidate_index) {
  do {
    ++(*candidate_index);
    if (static_cast<unsigned int>(*candidate_index) == candidates.size())
      return 0;
  } while (!candidates[*candidate_index]);

  SetProperties* candidate = candidates[*candidate_index];
  if (current_set.size() - current_index < candidate->size)
    return 0;  // remaining sets are too big to be subsumed
  return candidate;
}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
subq %rax, %rsi
sarq $0x3, %rsi
movslq (%r8), %rdi
movq %rdi, %r10
incq %r10
movl %r10d, %r9d
cmpq %r9, %rsi
je 0x2ada
movq (%rax,%r10,8), %r9
incl %edi
incq %r10
testq %r9, %r9
je 0x2aa3
movl %edi, (%r8)
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
sarq $0x2, %rsi
movl %ecx, %eax
subq %rax, %rsi
movl 0x4(%r9), %ecx
xorl %eax, %eax
cmpq %rcx, %rsi
cmovaeq %r9, %rax
retq
incl %edi
movl %edi, (%r8)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
incq 0x49a9(%rip)            # 0x7160
callq 0x2140
movq %rax, 0x4a1d(%rip)      # 0x71e0
movq %rsp, %rdi
movq $0x1, (%rdi)
callq 0x310b
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x2f7a
movb $0x0, (%rbx)
movq %r14, %rdi
callq 0x2110
leaq 0x60(%rbx), %r14
movq %r14, %rdi
callq 0x2200
leaq 0x48(%rbx), %r15
movq 0x48(%rbx), %r12
movq 0x50(%rbx), %r13
cmpq %r13, %r12
je 0x2a4e
movq %r12, %rdi
callq 0x2210
addq $0x8, %r12
jmp 0x2a3b
movq %r14, %rdi
callq 0x2230
movq %r15, %rdi
callq 0x2c22
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2fdc
jmp 0x2a75
movq %rax, %rdi
callq 0x2c50
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %r14
leaq 0x8(%rdi), %r15
leaq 0x60(%rdi), %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x2f16
movq (%r15), %rsi
cmpq %r15, %rsi
je 0x2bee
movq 0x10(%rsi), %rbp
movq %r15, %rdi
callq 0x2f2c
movq %r13, %rdi
callq 0x2f3a
testq %rbp, %rbp
je 0x2bbe
callq *%rbp
jmp 0x2bbe
cmpb $0x1, (%rbx)
jne 0x2c08
movq %r12, %rdi
movq %r13, %rsi
callq 0x2070
movq %r13, %rdi
callq 0x2f3a
jmp 0x2bbe
leaq 0x8(%rsp), %rdi
callq 0x2f3a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1698
movq 0x3c45(%rip), %rdi      # 0x4fd8
movl $0x80, %esi
callq 0x10b0
leaq 0x1c60(%rip), %rsi      # 0x3004
movq %rax, %rdi
callq 0x1120
movq %rax, %rdi
callq 0x1080
xorl %r14d, %r14d
leaq 0x1c72(%rip), %r15      # 0x3030
leaq -0x40(%rbp), %rbx
cmpq $0x90, %r14
je 0x13dd
movq (%r14,%r15), %rsi
movq %rbx, %rdi
callq 0x1802
addq $0x8, %r14
jmp 0x13c2
xorl %edi, %edi
callq 0x10f0
movl %eax, %edi
callq 0x1110
movl $0x3e8, %r13d           # imm = 0x3E8
leaq -0x40(%rbp), %rbx
leaq 0x3cfc(%rip), %r14      # 0x50f8
leaq -0x48(%rbp), %r15
subq $0x1, %r13
jb 0x1434
callq 0x1040
cltd
movl $0xc8, %ecx
idivl %ecx
incl %edx
movslq %edx, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1802
movq %r12, -0x48(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x14fa
jmp 0x1400
movq 0x3b9d(%rip), %rdi      # 0x4fd8
leaq 0x1bc4(%rip), %rsi      # 0x3006
callq 0x1120
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x1e94
movq %rbx, %rdi
movl %eax, %esi
callq 0x1180
movq %rax, %rdi
callq 0x1080
leaq -0x40(%rbp), %rdi
callq 0x1d14
leaq -0x40(%rbp), %rdi
callq 0x1716
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1490
jmp 0x1490
jmp 0x1490
jmp 0x1490
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x1716
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1130
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x68(%rax)
andq $0x0, 0x70(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
andq $0x0, 0x60(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movb $0x1, 0x78(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x172f
movq %rbx, %rdi
callq 0x1756
andq $0x0, (%rbx)
movq 0x389e(%rip), %rdi      # 0x4fd8
leaq 0x1994(%rip), %rsi      # 0x30d5
callq 0x1120
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x14ae
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17a6
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movslq 0x6c(%rbx), %rax
cmpq %rax, %r15
jge 0x178f
cmpb $0x0, 0x78(%rbx)
jne 0x178a
movq 0x30(%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x1756
incq %r15
jmp 0x176e
movl $0x80, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1140
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rdi, %rax
movq (%rax), %r14
testq %r14, %r14
je 0x17f1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ea8
testl %eax, %eax
js 0x17da
movl %eax, %ecx
cmpq %rbx, (%r14,%rcx,8)
je 0x17f4
movq %r14, 0x10(%r15)
cmpb $0x0, 0x78(%r14)
jne 0x17f1
cltq
leaq (%r14,%rax,8), %rax
addq $0x38, %rax
jmp 0x17bb
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x17a8
movq %rax, %r14
testq %rax, %rax
jne 0x185f
movq 0x10(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1ea8
leal 0x1(%rax), %r13d
movq %r12, %rdi
movl %r13d, %esi
movq %r15, %rdx
callq 0x1eca
movq %r12, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x1ef6
incl 0x8(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1874
testq %r14, %r14
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17a8
movq %rax, %r14
testq %rax, %rax
je 0x1a9b
movq %r14, %rdi
movq %r15, %rsi
callq 0x1ea8
movl %eax, %r12d
cmpb $0x0, 0x78(%r14)
je 0x1a54
movq %r14, %r15
jmp 0x1a77
movslq %r12d, %rax
leaq (%r14,%rax,8), %rcx
addq $0x38, %rcx
movq (%rcx), %r15
leaq 0x30(%r15), %rcx
cmpb $0x1, 0x78(%r15)
jne 0x1a5f
movq (%r15), %rcx
movq %rcx, (%r14,%rax,8)
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x1f24
movq %r15, %rdi
movl %r12d, %esi
callq 0x1f72
decl 0x8(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1aaa
testq %r14, %r14
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/CoderUper[P]BTree/BTree.cpp
// Function: BTree::bfs_print()
void BTree::bfs_print()
{
    if(!root) return;
    //初始化队列
    std::cout<<"init\n";
    int flag=0;
    Node* queue[num];
    memset(queue,0,sizeof(queue));
    int front=0,rear=0;
    queue[rear++]=root;
    while(front<rear)
    {
        Node *p=queue[front++];
        /*
        if(node_ptr.count(p))
        {
            std::cout<<"重复出现指针"<<p<<std::endl;
            flag=1;    
        }*/
        std::cout<<"[";
        for(int i=0;i<p->key_num;i++)
        {
            std::cout<<p->key[i]<<" ";
        }
        std::cout<<"]  ";
        //if(flag) break;
        node_ptr.insert(p);
        std::cout<<"key num in root is"<<p->key_num<<std::endl;
        for(int i=0;i<p->child_num;i++)
        {
            if(!p->is_leaf)
            {
                queue[rear++]=p->child[i];                   
                std::cout<<p->child[i]<<" ";
            }
        }
        std::cout<<"\n----------------\n";
    }
}

// Assembly:
cmpq $0x0, (%rdi)
je 0x1e92
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
movq 0x329f(%rip), %rbx      # 0x4fd8
leaq 0x13ad(%rip), %rsi      # 0x30ed
movq %rbx, %rdi
callq 0x1120
movq %rsp, -0x38(%rbp)
movl 0x8(%r12), %edx
movq %rsp, %r15
leaq 0xf(,%rdx,8), %r13
andq $-0x10, %r13
movq %r15, %r14
subq %r13, %r14
movq %r14, %rsp
negq %r13
shlq $0x3, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x10a0
movq (%r12), %rax
movq %rax, (%r15,%r13)
xorl %r15d, %r15d
pushq $0x1
popq %r13
leaq 0x1367(%rip), %r12      # 0x30f7
movslq %r13d, %rax
cmpq %rax, %r15
jge 0x1e80
movq %r15, -0x40(%rbp)
movq (%r14,%r15,8), %rax
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
leaq 0x1341(%rip), %rsi      # 0x30f3
callq 0x1120
xorl %r15d, %r15d
movq -0x30(%rbp), %rax
movslq 0x68(%rax), %rcx
cmpq %rcx, %r15
jge 0x1de3
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x1100
movq %rax, %rdi
movq %r12, %rsi
callq 0x1120
incq %r15
jmp 0x1dba
movq %rbx, %rdi
leaq 0x1308(%rip), %rsi      # 0x30f5
callq 0x1120
leaq 0x331f(%rip), %rdi      # 0x5118
leaq -0x30(%rbp), %rsi
callq 0x201c
movq %rbx, %rdi
leaq 0x12ed(%rip), %rsi      # 0x30f9
callq 0x1120
movq -0x30(%rbp), %rcx
movl 0x68(%rcx), %esi
movq %rax, %rdi
callq 0x1180
movq %rax, %rdi
callq 0x1080
xorl %r15d, %r15d
movq -0x30(%rbp), %rax
movslq 0x6c(%rax), %rcx
cmpq %rcx, %r15
jge 0x1e65
cmpb $0x0, 0x78(%rax)
jne 0x1e60
movq 0x30(%rax,%r15,8), %rsi
movslq %r13d, %rax
incl %r13d
movq %rsi, (%r14,%rax,8)
movq %rbx, %rdi
callq 0x10c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x1120
incq %r15
jmp 0x1e2b
movq -0x40(%rbp), %r15
incq %r15
movq %rbx, %rdi
leaq 0x1296(%rip), %rsi      # 0x310c
callq 0x1120
jmp 0x1d90
movq -0x38(%rbp), %rsp
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/CoderUper[P]BTree/./struct.h
// Function: Node::search(long)
int search(keyType e)
    {
        int i=0;
        while(i<key_num)
        {
            if(key[i]>e)
                return i-1;
            i++;
        }
        return key_num-1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x68(%rdi), %eax
movslq %eax, %rdx
xorl %ecx, %ecx
cmpq %rdx, %rcx
jge 0x1ec6
cmpq %rsi, (%rdi,%rcx,8)
jg 0x1ec4
incq %rcx
jmp 0x1eb4
movl %ecx, %eax
decl %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/CoderUper[P]BTree/./struct.h
// Function: Node::key_insert(int, long)
void key_insert(int pos,keyType e)
    {
        for(int i=key_num-1;i>=pos;i--)
            key[i+1]=key[i];
        key[pos]=e;
        //child[pos+1]=NULL;
        key_num++;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x68(%rdi), %rax
movslq %esi, %rcx
movq %rax, %rsi
cmpq %rcx, %rsi
jle 0x1eeb
movq -0x8(%rdi,%rsi,8), %r8
movq %r8, (%rdi,%rsi,8)
decq %rsi
jmp 0x1ed8
movq %rdx, (%rdi,%rcx,8)
incl %eax
movl %eax, 0x68(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/CoderUper[P]BTree/./struct.h
// Function: Node::child_insert(int, Node*)
void child_insert(int pos,Node* e)
    {
        for(int i=child_num-1;i>=pos;i--)
            child[i+1]=child[i];
        child[pos]=e;
        //child[pos+1]=NULL;
        child_num++;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x6c(%rdi), %rax
movslq %esi, %rcx
movq %rax, %rsi
cmpq %rcx, %rsi
jle 0x1f18
movq 0x28(%rdi,%rsi,8), %r8
movq %r8, 0x30(%rdi,%rsi,8)
decq %rsi
jmp 0x1f04
movq %rdx, 0x30(%rdi,%rcx,8)
incl %eax
movl %eax, 0x6c(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1f54
movl 0x68(%rdi), %ecx
cmpl %esi, %ecx
jle 0x1f54
movl %esi, %eax
leaq (%rdi,%rax,8), %rdx
addq $0x8, %rdx
movq -0x8(%rdx), %rax
cmpl %esi, %ecx
jle 0x1f6b
movq (%rdx), %r8
movq %r8, -0x8(%rdx)
addq $0x8, %rdx
incl %esi
jmp 0x1f41
movq 0x307d(%rip), %rdi      # 0x4fd8
leaq 0x11bd(%rip), %rsi      # 0x311f
callq 0x1120
xorl %eax, %eax
jmp 0x1f70
decl %ecx
movl %ecx, 0x68(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1fa2
movl 0x6c(%rdi), %ecx
cmpl %esi, %ecx
jle 0x1fa2
movl %esi, %eax
leaq (%rdi,%rax,8), %rdx
addq $0x38, %rdx
movq -0x8(%rdx), %rax
cmpl %esi, %ecx
jle 0x1fb9
movq (%rdx), %r8
movq %r8, -0x8(%rdx)
addq $0x8, %rdx
incl %esi
jmp 0x1f8f
movq 0x302f(%rip), %rdi      # 0x4fd8
leaq 0x1180(%rip), %rsi      # 0x3130
callq 0x1120
xorl %eax, %eax
jmp 0x1fbe
decl %ecx
movl %ecx, 0x6c(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %r14
movq %rdi, %rbx
callq 0xc430
pushq $0xa
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0xc590
leaq 0x40(%r14), %rsi
movq %rax, %rdi
callq 0xc430
movq %rax, %rdi
movl %ebp, %esi
callq 0xc590
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0xc430
movq %rax, %rdi
movl %ebp, %esi
callq 0xc590
addq $0x60, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0xc430
movq %rax, %rdi
movl %ebp, %esi
callq 0xc590
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xc0a0
leaq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0xc0a0
leaq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0xc0a0
addq $0x60, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc0a0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x195cd(%rip), %rsi     # 0x26148
callq 0xc5a0
testq %rax, %rax
je 0xcbbd
movq %rax, %rbx
movq %rax, %rdi
callq 0xc720
cmpl $0x1f, %eax
jne 0xcba8
movq %rbx, %rdi
callq 0xc720
cmpl $0x8b, %eax
sete %bpl
jmp 0xcbaa
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xc4a0
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc280
movq %rax, %rbx
leaq 0x1957c(%rip), %rsi     # 0x2614b
movq %rsp, %rdi
movq %r14, %rdx
callq 0xec1c
leaq 0x19580(%rip), %rdx     # 0x26161
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xebfd
callq 0xc050
movl (%rax), %edi
callq 0xc180
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0xebfd
movb $0x1, %bpl
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0xec92
xorl %ebp, %ebp
leaq 0x2fa7b(%rip), %rsi     # 0x3c6a0
movq 0x3233c(%rip), %rdx     # 0x3ef68
movq %rbx, %rdi
callq 0xc7e0
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0xc250
jmp 0xcc49
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0xc250
jmp 0xcc5b
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0xc250
testb %bpl, %bpl
jne 0xcc6d
jmp 0xcc75
movq %rax, %r14
movq %rbx, %rdi
callq 0xc3a0
movq %r14, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
xorl %ebp, %ebp
leaq 0x32ce2(%rip), %r14     # 0x3fa28
leaq 0x7(%rsp), %r15
cmpq %rbp, %r13
je 0xcd73
movb (%r12,%rbp), %al
movb %al, 0x7(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xee2c
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0xc410
incq %rbp
jmp 0xcd4b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xc250
movq %r14, %rdi
callq 0xc820