LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x38, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, (%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq %rax, %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
leaq 0x5f55(%rip), %rsi      # 0x903d
callq 0x4830
testb $0x1, %al
jne 0x30f3
jmp 0x310f
movq (%rsp), %rdi
callq 0x2e60
movq (%rsp), %rdi
subq $0x1, %rax
movl %eax, %edx
xorl %esi, %esi
callq 0x4860
jmp 0x313d
movq 0x8(%rsp), %rdi
leaq 0x5f67(%rip), %rsi      # 0x9082
callq 0x4830
testb $0x1, %al
jne 0x3126
jmp 0x3131
movq (%rsp), %rdi
callq 0x4950
jmp 0x313b
movl $0x1, %edi
callq 0x2170
jmp 0x313d
movq (%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x4a70
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movslq 0x14(%rsp), %rsi
callq 0x4330
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x10(%rsp), %eax
jg 0x3968
movq (%rsp), %rdi
movslq 0x8(%rsp), %rsi
callq 0x4330
movl (%rax), %eax
cmpl 0xc(%rsp), %eax
jge 0x3947
movb $0x0, 0x27(%rsp)
jmp 0x396d
movq (%rsp), %rdi
movslq 0x8(%rsp), %rsi
callq 0x4330
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3920
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x2f50
movq (%rsp), %rdi
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
callq 0x38f0
movb %al, 0xf(%rsp)
jmp 0x489b
leaq 0x20(%rsp), %rdi
callq 0x3050
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x48af
jmp 0x48ce
jmp 0x4937
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3050
jmp 0x493c
movl 0x38(%rsp), %eax
subl 0x3c(%rsp), %eax
cmpl $0x64, %eax
jge 0x48ed
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
callq 0x4aa0
movl 0x3c(%rsp), %eax
cmpl 0x38(%rsp), %eax
jge 0x4937
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
callq 0x4bb0
movl %eax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl 0x10(%rsp), %edx
subl $0x1, %edx
callq 0x4860
movq 0x40(%rsp), %rdi
movl 0x10(%rsp), %esi
addl $0x1, %esi
movl 0x38(%rsp), %edx
callq 0x4860
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2e60
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x4a6b
movl 0x24(%rsp), %eax
movl %eax, 0x2c(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x2c(%rsp)
movb %al, 0x17(%rsp)
jbe 0x49d5
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x4330
movl (%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x4330
movq %rax, %rcx
movl 0x10(%rsp), %eax
cmpl (%rcx), %eax
setg %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x49df
jmp 0x4a59
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x4330
movl (%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x4330
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x4330
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x4330
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movl 0x2c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x498d
jmp 0x4a5b
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4961
addq $0x38, %rsp
retq
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0x4ba7
movl 0x1c(%rsp), %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x24(%rsp)
movb %al, 0x1b(%rsp)
jle 0x4b15
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x4330
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x4330
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl (%rcx), %eax
setg %al
movb %al, 0x1b(%rsp)
movb 0x1b(%rsp), %al
testb $0x1, %al
jne 0x4b1f
jmp 0x4b95
movq 0x30(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x4330
movl (%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x4330
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x4330
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movl 0x20(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x4330
movl 0x10(%rsp), %ecx
movl %ecx, (%rax)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4acf
jmp 0x4b97
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4ab9
addq $0x38, %rsp
retq
nopl (%rax)
// File: kkloberdanz[P]Sort/./sort.cpp
// Function: int kgk::partition<int>(std::vector<int, std::allocator<int>>&, 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x4330
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0x4c84
movq 0x30(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0x4330
movl (%rax), %eax
cmpl 0x24(%rsp), %eax
jg 0x4c72
movq 0x30(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x4330
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0x4330
movl (%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x4330
movl 0x10(%rsp), %ecx
movl %ecx, (%rax)
movl 0x1c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0x4330
movl 0x14(%rsp), %ecx
movl %ecx, (%rax)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x4c74
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x4be6
movq 0x30(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x4330
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x4330
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x4330
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x4330
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movl 0x20(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movl $0x0, 0x64(%rsp)
movl %edi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
cmpl $0x2, 0x60(%rsp)
jg 0x2453
movq 0x58(%rsp), %rax
movq (%rax), %rdi
callq 0x24e0
movl $0x1, 0x64(%rsp)
jmp 0x24c0
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x2520
movq (%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x2530
jmp 0x2492
movl $0x0, 0x64(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x25f0
jmp 0x24c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x25f0
jmp 0x24c9
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x258, %rsp            # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq 0x248(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x29d0
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movl $0x3, %edx
callq 0x2a20
leaq 0x3acf(%rip), %rdi      # 0x6050
xorl %eax, %eax
callq 0x2030
jmp 0x258a
movq 0x250(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl $0x1, %edx
callq 0x2ab0
jmp 0x25a3
leaq 0x3ab5(%rip), %rdi      # 0x605f
xorl %eax, %eax
callq 0x2030
jmp 0x25b3
callq 0x2220
jmp 0x25ba
leaq 0x30(%rsp), %rdi
callq 0x2cd0
xorl %eax, %eax
addq $0x258, %rsp            # imm = 0x258
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2cd0
movq 0x18(%rsp), %rdi
callq 0x22a0
// File: 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:
subq $0xe8, %rsp
movb %dl, %al
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
andb $0x1, %al
movb %al, 0xd7(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x2210
movl $0x0, 0xac(%rsp)
movq 0xd8(%rsp), %rdi
callq 0x2e40
movb %al, 0x2f(%rsp)
jmp 0x2afd
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x2b0a
jmp 0x2c94
movq 0xd8(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x2e60
jmp 0x2b1e
leaq 0x78(%rsp), %rax
movq %rax, 0x70(%rsp)
testb $0x1, 0xd7(%rsp)
je 0x2b41
leaq 0xb0(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x2b4b
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x2fd0
jmp 0x2b73
movq 0x68(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x2fd0
jmp 0x2b84
leaq 0x60(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x40(%rsp), %rdx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x39d0
jmp 0x2ba0
movq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x2f70
movb %dl, 0xf(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x2bba
movb 0xf(%rsp), %al
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movb %al, 0x38(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x3960
movl 0xac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xac(%rsp)
movl 0xac(%rsp), %eax
movl $0x2710, %ecx           # imm = 0x2710
xorl %edx, %edx
divl %ecx
cmpl $0x0, %edx
jne 0x2c79
movl 0xac(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0xe0(%rsp), %rdi
callq 0x3020
movl 0x8(%rsp), %esi
movq %rax, %rdx
leaq 0x344b(%rip), %rdi      # 0x606d
xorl %eax, %eax
callq 0x2030
jmp 0x2c2b
jmp 0x2c79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x2ca9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x2c88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x3960
jmp 0x2c88
leaq 0x78(%rsp), %rdi
callq 0x2100
jmp 0x2aea
leaq 0x78(%rsp), %rdi
callq 0x2100
jmp 0x2ca9
leaq 0xb0(%rsp), %rdi
callq 0x2100
addq $0xe8, %rsp
retq
leaq 0xb0(%rsp), %rdi
callq 0x2100
movq 0xa0(%rsp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: STrix8[P]RasPiDS3/RasPiDS3.cpp
// Function: RPDS3::DualShock3::update()
void DualShock3::update() {
	memcpy(beforeButtonData, buttonData, sizeof(beforeButtonData));
	memcpy(buttonData, readButtonData, sizeof(buttonData));
	memcpy(stickData, readStickData, sizeof(stickData));
	memcpy(axisData, readAxisData, sizeof(axisData));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x25c(%rax), %rcx
movq %rcx, 0x290(%rax)
movq 0x264(%rax), %rcx
movq %rcx, 0x298(%rax)
movq 0x228(%rax), %rcx
movq %rcx, 0x25c(%rax)
movq 0x230(%rax), %rcx
movq %rcx, 0x264(%rax)
movq 0x238(%rax), %rcx
movq %rcx, 0x26c(%rax)
movq 0x240(%rax), %rcx
movq %rcx, 0x274(%rax)
movq 0x248(%rax), %rcx
movq %rcx, 0x27c(%rax)
movq 0x250(%rax), %rcx
movq %rcx, 0x284(%rax)
movl 0x258(%rax), %ecx
movl %ecx, 0x28c(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: STrix8[P]RasPiDS3/RasPiDS3.cpp
// Function: RPDS3::DualShock3::button(RPDS3::ButtonsNum, bool)
bool DualShock3::button(ButtonsNum Button, bool onlyFlag) {
	if (onlyFlag) {
		for (int i = 0; i < NumButtons; ++i) {
			if (buttonData[i]) {
				if (i != Button)
					return false;
			}
		}
	}
	return buttonData[Button];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, -0x15(%rbp)
je 0x315e
movl $0x0, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jge 0x315c
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
testb $0x1, 0x25c(%rax,%rcx)
je 0x314f
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x314d
movb $0x0, -0x1(%rbp)
jmp 0x3171
jmp 0x314f
jmp 0x3151
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3127
jmp 0x315e
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
movb 0x25c(%rax,%rcx), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: roberto-bayardo[P]google-extremal-sets/all-maximal-sets-cardinality.cc
// Function: google_extremal_sets::AllMaximalSetsCardinality::PrepareForDataScan(google_extremal_sets::DataSourceIterator*, unsigned int, long)
bool AllMaximalSetsCardinality::PrepareForDataScan(
    DataSourceIterator* data, uint32_t max_item_id, off_t resume_offset) {
  assert(candidates_.size() == 0);
  candidates_.resize(max_item_id);
  std::cerr << "; Starting new dataset scan at offset: "
            << resume_offset << std::endl;
  return data->Seek(resume_offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x18, %rdi
callq 0x3040
cmpq $0x0, %rax
jne 0x2920
jmp 0x293f
leaq 0x570f(%rip), %rdi      # 0x8036
leaq 0x5720(%rip), %rsi      # 0x804e
movl $0x83, %edx
leaq 0x5734(%rip), %rcx      # 0x806e
callq 0x2140
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3070
movq 0xa698(%rip), %rdi      # 0xcff0
leaq 0x577f(%rip), %rsi      # 0x80de
callq 0x2200
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x23a0
movq %rax, %rdi
movq 0xa63e(%rip), %rsi      # 0xcfb8
callq 0x2240
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5b20
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3100
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3170
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3130
testb $0x1, %al
jne 0x2b75
jmp 0x2bf2
leaq -0x18(%rbp), %rdi
callq 0x31a0
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x40(%rbp)
addq $0x18, %rdi
callq 0x3040
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x2bc6
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x3070
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x31c0
movq %rax, %rdi
leaq -0x28(%rbp), %rsi
callq 0x31e0
leaq -0x18(%rbp), %rdi
callq 0x3250
jmp 0x2b55
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3430
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x2c77
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x33f0
movq -0x48(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2e10
movq -0x20(%rbp), %rdi
callq 0x75e0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2c22
movq -0x10(%rbp), %rdi
callq 0x2f30
movl $0x0, -0x24(%rbp)
movq -0x48(%rbp), %rdi
movl -0x24(%rbp), %eax
movq %rax, -0x58(%rbp)
addq $0x18, %rdi
callq 0x3040
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x2d3d
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x31c0
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3430
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x2d26
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x33f0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x2d19
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2e10
movq -0x40(%rbp), %rdi
callq 0x75e0
jmp 0x2d1b
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2cc8
movq -0x30(%rbp), %rdi
callq 0x2f30
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2c87
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x3450
movq 0xa277(%rip), %rdi      # 0xcfc8
movq 0xa278(%rip), %rsi      # 0xcfd0
callq 0x2240
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: roberto-bayardo[P]google-extremal-sets/all-maximal-sets-cardinality.cc
// Function: google_extremal_sets::(anonymous namespace)::DoesSubsume(__gnu_cxx::__normal_iterator<unsigned int const*, std::vector<unsigned int, std::allocator<unsigned int>>>, __gnu_cxx::__normal_iterator<unsigned int const*, std::vector<unsigned int, std::allocator<unsigned int>>>, unsigned int const*, unsigned int const*)
inline bool DoesSubsume(
    std::vector<uint32_t>::const_iterator it1,
    const std::vector<uint32_t>::const_iterator it1_end,
    const uint32_t* it2,
    const uint32_t* const it2_end) {
  while (it2 != it2_end) {
    it1 = std::lower_bound(it1, it1_end, *it2);
    if (it1 == it1_end || *it1 > *it2)
      return false;
    ++it1;
    ++it2;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x2e00
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x35f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3640
testb $0x1, %al
jne 0x2de3
leaq -0x10(%rbp), %rdi
callq 0x3680
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jbe 0x2de9
movb $0x0, -0x1(%rbp)
jmp 0x2e04
leaq -0x10(%rbp), %rdi
callq 0x3410
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x2d88
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
incq %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x2e50
jmp 0x2e3c
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x2e52
jmp 0x2e46
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x2e73
jmp 0x2e92
jmp 0x2ec4
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq 0xa169(%rip), %rdi      # 0xcfc8
callq 0x22e0
movq %rax, %rdi
movl $0xa, %esi
callq 0x2290
jmp 0x2ec4
movq -0x10(%rbp), %rsi
movq 0xa14a(%rip), %rdi      # 0xcfc8
callq 0x7600
movq %rax, %rdi
movl $0xa, %esi
callq 0x2290
jmp 0x2ec4
movq 0xa12f(%rip), %rdi      # 0xcfc8
leaq 0x5266(%rip), %rsi      # 0x8106
callq 0x2200
leaq 0x51a0(%rip), %rdi      # 0x804c
leaq 0x519b(%rip), %rsi      # 0x804e
movl $0xf5, %edx
leaq 0x524d(%rip), %rcx      # 0x810c
callq 0x2140
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3430
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jne 0x333f
movq $0x0, -0x8(%rbp)
jmp 0x33a2
jmp 0x3341
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq (%rax), %rsi
callq 0x35d0
cmpq $0x0, (%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x330b
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq (%rax), %rsi
callq 0x35d0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2f10
movl -0x24(%rbp), %ecx
subq %rcx, %rax
movq -0x38(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jae 0x339a
movq $0x0, -0x8(%rbp)
jmp 0x33a2
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq 0x8625(%rip), %rax      # 0xb160
addq $0x1, %rax
movq %rax, 0x861a(%rip)      # 0xb160
callq 0x5a00
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8684(%rip)      # 0xb1e0
movl $0x1, 0x4(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x5b00
leaq 0x8(%rsp), %rdi
callq 0x5a30
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rsi
movq %rsi, (%rsp)
addq $0x20, %rsi
leaq 0x28(%rsp), %rdi
callq 0x5260
jmp 0x3152
movq (%rsp), %rax
movb $0x0, (%rax)
leaq 0x28(%rsp), %rdi
callq 0x52d0
movq (%rsp), %rdi
addq $0x60, %rdi
callq 0x2210
movq (%rsp), %rax
addq $0x48, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4b10
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4260
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x55e0
testb $0x1, %al
jne 0x31b0
jmp 0x31d9
leaq 0x18(%rsp), %rdi
callq 0x5620
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x2220
jmp 0x31cb
jmp 0x31cd
leaq 0x18(%rsp), %rdi
callq 0x5630
jmp 0x319b
movq (%rsp), %rdi
addq $0x60, %rdi
callq 0x2240
movq (%rsp), %rdi
addq $0x48, %rdi
callq 0x3750
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x37b0
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x3b10
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
leaq 0x38(%rsp), %rdi
callq 0x4c60
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x4ca0
testb $0x1, %al
jne 0x36cb
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x4cc0
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0x4d40
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4d70
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x4cf0
movq %rax, 0x20(%rsp)
jmp 0x36fc
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
jne 0x36df
movl $0x3, 0x1c(%rsp)
jmp 0x3704
movq 0x10(%rsp), %rdi
addq $0x60, %rdi
leaq 0x38(%rsp), %rsi
callq 0x2080
movl $0x2, 0x1c(%rsp)
jmp 0x3704
movl $0x0, 0x1c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4d90
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x372d
jmp 0x371c
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x364c
jmp 0x372b
jmp 0x3747
cmpq $0x0, 0x48(%rsp)
je 0x3742
callq *0x48(%rsp)
movq $0x0, 0x48(%rsp)
jmp 0x364c
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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
subq $0x110, %rsp            # imm = 0x110
movl $0x0, -0x4(%rbp)
xorl %edx, %edx
movl %edx, %ecx
leaq -0x20(%rbp), %rdi
movq %rcx, %rsi
callq 0x2150
movq 0x5c0f(%rip), %rdi      # 0x6fd8
movl $0x80, %esi
callq 0x1040
movq %rax, -0xe8(%rbp)
jmp 0x13dc
movq -0xe8(%rbp), %rdi
leaq 0x2c1a(%rip), %rsi      # 0x4004
callq 0x1110
movq %rax, -0xf0(%rbp)
jmp 0x13f8
movq -0xf0(%rbp), %rdi
movq 0x5bc2(%rip), %rsi      # 0x6fc8
callq 0x1150
jmp 0x140d
leaq -0xc0(%rbp), %rdi
leaq 0x2c15(%rip), %rsi      # 0x4030
movl $0x90, %edx
callq 0x10d0
movl $0x12, -0xc4(%rbp)
movl $0x0, -0xc8(%rbp)
movl -0xc8(%rbp), %eax
cmpl -0xc4(%rbp), %eax
jge 0x148e
movslq -0xc8(%rbp), %rax
movq -0xc0(%rbp,%rax,8), %rsi
leaq -0x20(%rbp), %rdi
callq 0x23f0
jmp 0x1461
jmp 0x1463
movl -0xc8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc8(%rbp)
jmp 0x1439
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2250
jmp 0x15be
movq $0x1, -0xd0(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x10f0
movl %eax, %edi
callq 0x1100
cmpq $0x3e8, -0xd0(%rbp) # imm = 0x3E8
jg 0x153a
callq 0x1050
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rax
addl %edx, %eax
imull $0xc8, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal 0x1(%rax,%rcx), %eax
movl %eax, -0xd4(%rbp)
movslq -0xd4(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x23f0
jmp 0x1500
movslq -0xd4(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq 0x5bf3(%rip), %rdi      # 0x7108
leaq -0xe0(%rbp), %rsi
callq 0x1650
jmp 0x1523
movq -0xd0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd0(%rbp)
jmp 0x14a9
movq 0x5a97(%rip), %rdi      # 0x6fd8
leaq 0x2abe(%rip), %rsi      # 0x4006
callq 0x1110
movq %rax, -0xf8(%rbp)
jmp 0x1556
leaq -0x20(%rbp), %rdi
callq 0x2f90
movl %eax, -0xfc(%rbp)
jmp 0x1567
movl -0xfc(%rbp), %esi
movq -0xf8(%rbp), %rdi
callq 0x1190
movq %rax, -0x108(%rbp)
jmp 0x1582
movq -0x108(%rbp), %rdi
movq 0x5a38(%rip), %rsi      # 0x6fc8
callq 0x1150
jmp 0x1597
leaq -0x20(%rbp), %rdi
callq 0x2d80
jmp 0x15a2
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2250
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x11a0
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x80, %edi
callq 0x1120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x2ff0
jmp 0x21e7
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x222f
movq 0x4ddb(%rip), %rdi      # 0x6fd8
leaq 0x1ee9(%rip), %rsi      # 0x40ed
callq 0x1110
movl $0x1, %edi
callq 0x1160
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x80, %esi
callq 0x1130
jmp 0x2239
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x11a0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x227a
movq -0x10(%rbp), %rdi
movq (%rdi), %rsi
callq 0x22b0
jmp 0x2278
jmp 0x227a
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq 0x4d4c(%rip), %rdi      # 0x6fd8
leaq 0x1e42(%rip), %rsi      # 0x40d5
callq 0x1110
jmp 0x229a
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1770
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2333
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jge 0x230f
movq -0x10(%rbp), %rax
testb $0x1, 0x78(%rax)
jne 0x2302
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rsi
callq 0x22b0
jmp 0x2304
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x22d6
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x232b
movq -0x28(%rbp), %rdi
movl $0x80, %esi
callq 0x1130
movq $0x0, -0x10(%rbp)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x23d0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3050
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x2398
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x2398
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x23d8
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
testb $0x1, 0x78(%rax)
je 0x23b8
movq $0x0, -0x8(%rbp)
jmp 0x23d8
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq 0x30(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x235f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x2340
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2422
movb $0x0, -0x1(%rbp)
jmp 0x247e
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3050
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
addl $0x1, %esi
movq -0x18(%rbp), %rdx
callq 0x30c0
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
addl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3130
movq -0x30(%rbp), %rdi
movl 0x8(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x8(%rdi)
movq -0x20(%rbp), %rsi
callq 0x2490
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x2340
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x27a5
movb $0x0, -0x1(%rbp)
jmp 0x2846
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3050
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x78(%rax)
jne 0x2814
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq 0x30(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movb 0x78(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x27e4
jmp 0x27f2
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x27d5
movq -0x30(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x31a0
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x3250
movq -0x38(%rbp), %rdi
movl 0x8(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rdi)
movq -0x20(%rbp), %rsi
callq 0x2860
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CoderUper[P]BTree/./struct.h
// Function: Node::Node()
Node()
    {
        key_num=0;
        child_num=1;
        memset(key,0,sizeof(key));
        memset(child,0,sizeof(child));
        parent=NULL;
        is_leaf=true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, 0x68(%rdi)
movl $0x1, 0x6c(%rdi)
xorl %esi, %esi
movl $0x30, %edx
callq 0x10a0
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10a0
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
movb $0x1, 0x78(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x68(%rcx), %eax
jge 0x309f
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jle 0x3094
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x30ac
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x306b
movq -0x28(%rbp), %rax
movl 0x68(%rax), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x68(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x310c
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x30e0
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdx
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x68(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x68(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x6c(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x317e
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rdx
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, 0x30(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3150
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdx
movslq -0xc(%rbp), %rcx
movq %rdx, 0x30(%rax,%rcx,8)
movl 0x6c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x6c(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x31c9
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x68(%rcx), %eax
jl 0x31e5
movq 0x3e08(%rip), %rdi      # 0x6fd8
leaq 0xf61(%rip), %rsi       # 0x4138
callq 0x1110
movl $0x0, -0x4(%rbp)
jmp 0x323d
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x68(%rcx), %eax
jge 0x322a
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x31fa
movq -0x28(%rbp), %rax
movl 0x68(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x68(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x3279
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x6c(%rcx), %eax
jl 0x3296
movq 0x3d58(%rip), %rdi      # 0x6fd8
leaq 0xec2(%rip), %rsi       # 0x4149
callq 0x1110
movq $0x0, -0x8(%rbp)
jmp 0x32f4
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x6c(%rcx), %eax
jge 0x32df
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq 0x30(%rax,%rcx,8), %rdx
movslq -0x24(%rbp), %rcx
movq %rdx, 0x30(%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x32ad
movq -0x30(%rbp), %rax
movl 0x6c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x6c(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe580
movq %rax, %rdi
movl $0xa, %esi
callq 0xe780
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0xe580
movq %rax, %rdi
movl $0xa, %esi
callq 0xe780
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0xe580
movq %rax, %rdi
movl $0xa, %esi
callq 0xe780
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
callq 0xe580
movq %rax, %rdi
movl $0xa, %esi
callq 0xe780
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)