LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: qf_count_key_value
uint64_t qf_count_key_value(const QF *qf, uint64_t key, uint64_t value)
{
	__uint128_t hash = key;
	uint64_t hash_remainder   = hash & BITMASK(qf->metadata->bits_per_slot);
	int64_t hash_bucket_index = hash >> qf->metadata->bits_per_slot;

	if (!is_occupied(qf, hash_bucket_index))
		return 0;

	int64_t runstart_index = hash_bucket_index == 0 ? 0 : run_end(qf,
																																hash_bucket_index-1)
		+ 1;
	if (runstart_index < hash_bucket_index)
		runstart_index = hash_bucket_index;

	/* printf("MC RUNSTART: %02lx RUNEND: %02lx\n", runstart_index, runend_index); */

	uint64_t current_remainder, current_count, current_end;
	do {
		current_end = decode_counter(qf, runstart_index, &current_remainder,
																 &current_count);
		if (current_remainder == hash_remainder)
			return current_count;
		runstart_index = current_end + 1;
	} while (!is_runend(qf, current_end));

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x38(%rax), %rcx
pushq $-0x1
popq %rax
movq %rax, %rbp
shlq %cl, %rbp
cmpq $0x40, %rcx
notq %rbp
cmoveq %rax, %rbp
movzbl %cl, %edx
xorl %r15d, %r15d
movq %rsi, %rdi
xorl %esi, %esi
callq 0x21a0
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0xec1e
testl %eax, %eax
je 0xec0c
testq %r12, %r12
je 0xebbf
leaq -0x1(%r12), %rsi
movq %rbx, %rdi
callq 0xec56
incq %rax
jmp 0xebc1
xorl %eax, %eax
andq %r14, %rbp
cmpq %r12, %rax
cmovgq %rax, %r12
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r13
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0xed85
cmpq %rbp, 0x10(%rsp)
je 0xec07
movq %rax, %r12
incq %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0xef61
testl %eax, %eax
je 0xebd8
jmp 0xec0c
movq 0x8(%rsp), %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: qf_iterator
bool qf_iterator(const QF *qf, QFi *qfi, uint64_t position)
{
  if (position == 0xffffffffffffffff) {
    qfi->current = 0xffffffffffffffff;
    qfi->qf = qf;
    return false;
  }
	assert(position < qf->metadata->nslots);
	if (!is_occupied(qf, position)) {
		uint64_t block_index = position;
		uint64_t idx = bitselect(get_block(qf, block_index)->occupieds[0], 0);
		if (idx == 64) {
			while(idx == 64 && block_index < qf->metadata->nblocks) {
				block_index++;
				idx = bitselect(get_block(qf, block_index)->occupieds[0], 0);
			}
		}
		position = block_index * SLOTS_PER_BLOCK + idx;
	}

	qfi->qf = qf;
	qfi->num_clusters = 0;
	qfi->run = position;
	qfi->current = position == 0 ? 0 : run_end(qfi->qf, position-1) + 1;
	if (qfi->current < position)
		qfi->current = position;

#ifdef LOG_CLUSTER_LENGTH
	qfi->c_info = (cluster_data* )calloc(qf->metadata->nslots/32, sizeof(cluster_data));
	qfi->cur_start_index = position;
	qfi->cur_length = 1;
#endif

	if (qfi->current >= qf->metadata->nslots)
		return false;
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
cmpq $-0x1, %rdx
je 0xf029
movq %rdx, %rbx
movq %r14, %rdi
movq %rdx, %rsi
callq 0xec1e
testl %eax, %eax
jne 0xf03f
movq 0x8(%r14), %rbp
movq 0x10(%r14), %r12
movabsq $0x3ffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFF
andq 0x38(%rbp), %rax
leaq 0x11(,%rax,8), %r13
movq %r13, %rax
imulq %rbx, %rax
movq 0x1(%r12,%rax), %rdi
xorl %esi, %esi
callq 0xf088
cmpq $0x40, %rax
jne 0xf038
movq 0x50(%rbp), %rbp
leaq 0x1(%rbx), %rax
imulq %r13, %rax
addq %rax, %r12
incq %r12
cmpq %rbp, %rbx
jae 0xf035
incq %rbx
movq (%r12), %rdi
xorl %esi, %esi
callq 0xf088
addq %r13, %r12
cmpq $0x40, %rax
je 0xf00b
jmp 0xf038
orq $-0x1, 0x10(%r15)
movq %r14, (%r15)
xorl %eax, %eax
jmp 0xf079
pushq $0x40
popq %rax
shlq $0x6, %rbx
addq %rax, %rbx
movq %r14, (%r15)
andl $0x0, 0x24(%r15)
movq %rbx, 0x8(%r15)
testq %rbx, %rbx
je 0xf061
leaq -0x1(%rbx), %rsi
movq %r14, %rdi
callq 0xec56
incq %rax
jmp 0xf063
xorl %eax, %eax
cmpq %rbx, %rax
cmovaq %rax, %rbx
movq %rbx, 0x10(%r15)
movq 0x8(%r14), %rax
cmpq 0x10(%rax), %rbx
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: bitselect(unsigned long, int)
static inline int popcnt(uint64_t val)
{
	asm("popcnt %[val], %[val]"
			: [val] "+r" (val)
			:
			: "cc");
	return val;
}

// Assembly:
movq %rdi, %rax
popcntq %rax, %rax
cmpl %esi, %eax
jle 0xf152
movq %rdi, %rax
shrq %rax
movabsq $0x5555555555555555, %rcx # imm = 0x5555555555555555
andq %rax, %rcx
movq %rdi, %rax
subq %rcx, %rax
movabsq $0x3333333333333333, %rcx # imm = 0x3333333333333333
movq %rax, %rdx
andq %rcx, %rdx
shrq $0x2, %rax
andq %rcx, %rax
addq %rdx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
addq %rax, %rcx
movabsq $0xf0f0f0f0f0f0f0f, %rdx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rdx
movabsq $-0x101010101010101, %rcx # imm = 0xFEFEFEFEFEFEFEFF
imulq %rdx, %rcx
movslq %esi, %rax
movabsq $0x101010101010100, %rsi # imm = 0x101010101010100
leaq 0x1(%rsi), %r8
imulq %rax, %r8
movabsq $-0x7f7f7f7f7f7f7f80, %r9 # imm = 0x8080808080808080
orq %r9, %r8
addq %rcx, %r8
andq %r9, %r8
popcntq %r8, %r8
shll $0x3, %r8d
movslq %r8d, %rcx
imulq %rsi, %rdx
shrq %cl, %rdx
movl $0xff, %esi
shrq %cl, %rdi
andq %rsi, %rdx
subq %rdx, %rax
andq %rsi, %rdi
shlq $0x8, %rax
orq %rdi, %rax
leaq 0x2a06(%rip), %rdx      # 0x11b50
movzbl (%rdx,%rax), %eax
addq %rcx, %rax
retq
pushq $0x40
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: qfi_get
int qfi_get(const QFi *qfi, uint64_t *key, uint64_t *value, uint64_t *count)
{
	assert(qfi->current < qfi->qf->metadata->nslots);

	uint64_t current_remainder, current_count;
	decode_counter(qfi->qf, qfi->current, &current_remainder, &current_count);

	*key = (qfi->run << qfi->qf->metadata->bits_per_slot) | current_remainder;
	*value = 0;   // for now we are not using value
	*count = current_count; 
	
	qfi->qf->metadata->ndistinct_elts++;
	qfi->qf->metadata->nelts += current_count;

	/*qfi->current = end_index;*/ 		//get should not change the current index
																		//of the iterator
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %r13
movq 0x10(%rdi), %rsi
leaq 0x10(%rsp), %rbp
leaq 0x8(%rsp), %rcx
movq %r13, %rdi
movq %rbp, %rdx
callq 0xed85
movq 0x8(%r12), %rax
movq 0x8(%r13), %rdx
movb 0x38(%rdx), %cl
shlq %cl, %rax
orq (%rbp), %rax
movq %rax, (%r15)
andq $0x0, (%r14)
leaq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, %xmm0
movq %rax, (%rbx)
shufpd $0x2, 0x28b1(%rip), %xmm0 # xmm0 = xmm0[0],mem[1]
movdqu 0x58(%rdx), %xmm1
paddq %xmm1, %xmm0
movdqu %xmm0, 0x58(%rdx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: qf_merge
void qf_merge(QF *qfa, QF *qfb, QF *qfc) 
{
	QFi qfia, qfib;
	qf_iterator(qfa, &qfia, 0);
	qf_iterator(qfb, &qfib, 0);

	uint64_t keya, valuea, counta, keyb, valueb, countb;
	qfi_get(&qfia, &keya, &valuea, &counta);
	qfi_get(&qfib, &keyb, &valueb, &countb);
	do {
		if (keya < keyb) {
			qf_insert(qfc, keya, valuea, counta, true, true);
			qfi_next(&qfia);
			qfi_get(&qfia, &keya, &valuea, &counta);
		}
		else {
			qf_insert(qfc, keyb, valueb, countb, true, true);
			qfi_next(&qfib);
			qfi_get(&qfib, &keyb, &valueb, &countb);
		}
	} while(!qfi_end(&qfia) && !qfi_end(&qfib));

	if (!qfi_end(&qfia)) {
		do {
			qfi_get(&qfia, &keya, &valuea, &counta);
			qf_insert(qfc, keya, valuea, counta, true, true);
		} while(!qfi_next(&qfia));
	}
	if (!qfi_end(&qfib)) {
		do {
			qfi_get(&qfib, &keyb, &valueb, &countb);
			qf_insert(qfc, keyb, valueb, countb, true, true);
		} while(!qfi_next(&qfib));
	}

	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %r12
leaq 0x68(%rsp), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0xef99
leaq 0x38(%rsp), %rbp
movq %r12, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0xef99
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x18(%rsp), %rcx
movq %r14, %rdi
callq 0xf156
leaq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbp, %rdi
callq 0xf156
pushq $0x1
popq %r12
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rax
cmpq %rax, %rsi
jae 0xf3d9
movq 0x18(%rsp), %rcx
movq %rbx, %rdi
movl %r12d, %r8d
movl %r12d, %r9d
callq 0xdb69
movq %r14, %rdi
callq 0xf1de
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x18(%rsp), %rcx
jmp 0xf409
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %rax, %rsi
movl %r12d, %r8d
movl %r12d, %r9d
callq 0xdb69
movq %rbp, %rdi
callq 0xf1de
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0xf156
movq 0x68(%rsp), %rax
movq 0x78(%rsp), %rcx
movq 0x8(%rax), %rax
movq 0x38(%rsp), %r13
movq 0x48(%rsp), %r15
cmpq 0x18(%rax), %rcx
jae 0xf480
movq 0x8(%r13), %rax
cmpq 0x18(%rax), %r15
jb 0xf39b
leaq 0x68(%rsp), %r14
leaq 0x18(%rsp), %r12
pushq $0x1
popq %rbp
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %r12, %rcx
callq 0xf156
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq %rbx, %rdi
movl %ebp, %r8d
movl %ebp, %r9d
callq 0xdb69
movq %r14, %rdi
callq 0xf1de
testl %eax, %eax
je 0xf447
movq 0x8(%r13), %rax
cmpq 0x18(%rax), %r15
jae 0xf4d6
leaq 0x38(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0x28(%rsp), %r12
leaq 0x8(%rsp), %r13
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0xf156
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
movl %ebp, %r8d
movl %ebp, %r9d
callq 0xdb69
movq %r14, %rdi
callq 0xf1de
testl %eax, %eax
je 0xf4a1
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: qf_inner_product
uint64_t qf_inner_product(QF *qfa, QF *qfb)
{
	uint64_t acc = 0;
	QFi qfi;
	QF *qf_mem, *qf_disk;

	// create the iterator on the larger QF.
	if (qfa->metadata->size > qfb->metadata->size) {
		qf_mem = qfb;
		qf_disk = qfa;
	} else {
		qf_mem = qfa;
		qf_disk = qfb;
	}

	qf_iterator(qf_disk, &qfi, 0);
	do {
		uint64_t key = 0, value = 0, count = 0;
		uint64_t count_mem;
		qfi_get(&qfi, &key, &value, &count);
		if ((count_mem = qf_count_key_value(qf_mem, key, 0)) > 0) {
			acc += count*count_mem;
		}
	} while (!qfi_next(&qfi));

	return acc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x8(%rdi), %rax
movq (%rax), %rax
movq 0x8(%rsi), %rcx
cmpq (%rcx), %rax
movq %rdi, %rbx
cmovaq %rsi, %rbx
cmovbeq %rsi, %rdi
xorl %r14d, %r14d
leaq 0x18(%rsp), %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0xef99
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %rsp, %rbp
andq $0x0, 0x8(%rsp)
andq $0x0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0xf156
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xeb56
imulq (%rsp), %rax
addq %rax, %r14
movq %r15, %rdi
callq 0xf1de
testl %eax, %eax
je 0xf767
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: qf_spin_lock(int volatile*, bool)
static inline bool qf_spin_lock(volatile int *lock, bool flag_spin)
{
	if (!flag_spin) {
		return !__sync_lock_test_and_set(lock, 1);
	} else {
		while (__sync_lock_test_and_set(lock, 1))
			while (*lock);
		return true;
	}

	return false;
}

// Assembly:
pushq $0x1
popq %rax
testl %esi, %esi
je 0xf81b
movl %eax, %ecx
xchgl %ecx, (%rdi)
testl %ecx, %ecx
je 0xf823
cmpl $0x0, (%rdi)
jne 0xf814
jmp 0xf80c
xchgl %eax, (%rdi)
testl %eax, %eax
sete %al
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: set_slot(quotient_filter const*, unsigned long, unsigned long)
static inline qfblock * get_block(const QF *qf, uint64_t block_index)
{
	return (qfblock *)(((char *)qf->blocks) + block_index * (sizeof(qfblock) +
																													 SLOTS_PER_BLOCK *
																													 qf->metadata->bits_per_slot /
																													 8));
}

// Assembly:
movq 0x8(%rdi), %rax
movq 0x38(%rax), %rcx
pushq $-0x1
popq %r9
movq %r9, %rax
shlq %cl, %rax
movq %rsi, %r10
shrq $0x6, %r10
movabsq $0x3ffffffffffffff, %r8 # imm = 0x3FFFFFFFFFFFFFF
andq %rcx, %r8
leaq 0x11(,%r8,8), %r8
imulq %r10, %r8
addq 0x10(%rdi), %r8
movl %esi, %edi
andl $0x3f, %edi
imulq %rcx, %rdi
shrq $0x3, %rdi
cmpq $0x40, %rcx
notq %rax
cmoveq %r9, %rax
imull %esi, %ecx
andb $0x7, %cl
shlq %cl, %rax
shlq %cl, %rdx
notq %rax
andq 0x11(%rdi,%r8), %rax
orq %rdx, %rax
movq %rax, 0x11(%rdi,%r8)
retq
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: get_slot(quotient_filter const*, unsigned long)
static inline uint64_t get_slot(const QF *qf, uint64_t index)
{
	assert(index < qf->metadata->xnslots);
	/* Should use __uint128_t to support up to 64-bit remainders, but gcc seems to generate buggy code.  :/  */
	uint64_t *p = (uint64_t *)&get_block(qf, index /
																			 SLOTS_PER_BLOCK)->slots[(index %
																																SLOTS_PER_BLOCK)
																			 * qf->metadata->bits_per_slot / 8];
	return (uint64_t)(((*p) >> (((index % SLOTS_PER_BLOCK) * qf->metadata->bits_per_slot)
															% 8)) & BITMASK(qf->metadata->bits_per_slot));
}

// Assembly:
movq %rsi, %rax
shrq $0x6, %rax
movq 0x8(%rdi), %rcx
movq 0x38(%rcx), %rcx
movabsq $0x3ffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFF
andq %rcx, %rdx
leaq 0x11(,%rdx,8), %rdx
imulq %rax, %rdx
addq 0x10(%rdi), %rdx
andl $0x3f, %esi
imulq %rcx, %rsi
movq %rsi, %rax
shrq $0x3, %rax
movq 0x11(%rax,%rdx), %rax
pushq $-0x1
popq %rdx
movq %rdx, %rdi
shlq %cl, %rdi
cmpq $0x40, %rcx
notq %rdi
cmoveq %rdx, %rdi
andb $0x7, %sil
movl %esi, %ecx
shrq %cl, %rax
andq %rdi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: shift_remainders(quotient_filter*, unsigned long, unsigned long)
static inline void shift_remainders(QF *qf, const uint64_t start_index, const
																		uint64_t empty_index)
{
	uint64_t last_word = (empty_index + 1) * qf->metadata->bits_per_slot / 64;
	const uint64_t first_word = start_index * qf->metadata->bits_per_slot / 64;
	int bend = ((empty_index + 1) * qf->metadata->bits_per_slot) % 64;
	const int bstart = (start_index * qf->metadata->bits_per_slot) % 64;

	while (last_word != first_word) {
		*REMAINDER_WORD(qf, last_word) = shift_into_b(*REMAINDER_WORD(qf, last_word-1),
																									*REMAINDER_WORD(qf, last_word),
																									0, bend, qf->metadata->bits_per_slot);
		last_word--;
		bend = 64;
	}
	*REMAINDER_WORD(qf, last_word) = shift_into_b(0, *REMAINDER_WORD(qf, last_word),
																								bstart, bend, qf->metadata->bits_per_slot);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %r15
movq %rdi, %r14
incq %rcx
movq 0x8(%rdi), %rbx
movq 0x38(%rbx), %rax
imulq %rax, %rcx
movq %rcx, %rsi
shrq $0x6, %rsi
imulq %rax, %r15
movq %r15, (%rsp)
shrq $0x6, %r15
andl $0x3f, %ecx
cmpq %rsi, %r15
je 0xf9c1
leaq -0x1(%rsi), %r12
movq 0x38(%rbx), %r8
movq 0x10(%r14), %r9
movq %r12, %rax
xorl %edx, %edx
divq %r8
leaq (,%r8,8), %r10
movabsq $0x1ffffffffffffff8, %rdi # imm = 0x1FFFFFFFFFFFFFF8
andq %rdi, %r10
addq $0x11, %r10
imulq %r10, %rax
addq %r9, %rax
movq 0x11(%rax,%rdx,8), %rdi
movq %rsi, %rax
xorl %edx, %edx
divq %r8
movq %rdx, %r13
movq %rax, %rbp
imulq %r10, %rbp
addq %r9, %rbp
movq 0x11(%rbp,%rdx,8), %rsi
xorl %edx, %edx
callq 0xfbee
movq %rax, 0x11(%rbp,%r13,8)
pushq $0x40
popq %rax
movl %eax, %ecx
movq %r12, %rsi
jmp 0xf953
movq 0x38(%rbx), %r8
movq %r15, %rax
xorl %edx, %edx
divq %r8
movq %rax, %r15
movq %rdx, %r12
leaq (,%r8,8), %rax
movabsq $0x1ffffffffffffff8, %rdx # imm = 0x1FFFFFFFFFFFFFF8
andq %rdx, %rax
movq (%rsp), %rdx
andl $0x3f, %edx
addq $0x11, %rax
imulq %rax, %r15
addq 0x10(%r14), %r15
movq 0x11(%r15,%r12,8), %rsi
xorl %edi, %edi
callq 0xfbee
movq %rax, 0x11(%r15,%r12,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: shift_runends(quotient_filter*, long, unsigned long, unsigned long)
static inline void shift_runends(QF *qf, int64_t first, uint64_t last,
																 uint64_t distance)
{
	assert(last < qf->metadata->xnslots && distance < 64);
	uint64_t first_word = first / 64;
	uint64_t bstart = first % 64;
	uint64_t last_word = (last + distance + 1) / 64;
	uint64_t bend = (last + distance + 1) % 64;

	if (last_word != first_word) {
		METADATA_WORD(qf, runends, 64*last_word) = shift_into_b(METADATA_WORD(qf, runends, 64*(last_word-1)), 
																														METADATA_WORD(qf, runends, 64*last_word),
																														0, bend, distance);
		bend = 64;
		last_word--;
		while (last_word != first_word) {
			METADATA_WORD(qf, runends, 64*last_word) = shift_into_b(METADATA_WORD(qf, runends, 64*(last_word-1)), 
																															METADATA_WORD(qf, runends, 64*last_word),
																															0, bend, distance);
			last_word--;
		}
	}
	METADATA_WORD(qf, runends, 64*last_word) = shift_into_b(0, METADATA_WORD(qf,
																																					 runends,
																																					 64*last_word),
																													bstart, bend, distance);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rax
movabsq $0x1ffffffffffffff8, %r12 # imm = 0x1FFFFFFFFFFFFFF8
movabsq $0x3ffffffffffffff, %r13 # imm = 0x3FFFFFFFFFFFFFF
pushq $0x40
popq %rsi
cqto
idivq %rsi
movq %rax, %r15
leaq (%r8,%rcx), %rax
incq %rax
movq %rax, %rbx
shrq $0x6, %rbx
andl $0x3f, %eax
cmpq %r15, %rbx
jne 0xfa74
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %rbp
jmp 0xfb3c
movq %rdx, 0x8(%rsp)
addq %r8, %rcx
addq $-0x3f, %rcx
shrq $0x6, %rcx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %rbp
movq 0x38(%r14), %r12
shlq $0x3, %r12
movabsq $0x1ffffffffffffff8, %rdx # imm = 0x1FFFFFFFFFFFFFF8
andq %rdx, %r12
addq $0x11, %r12
imulq %r12, %rcx
movq 0x9(%rbp,%rcx), %rdi
imulq %rbx, %r12
movq 0x9(%rbp,%r12), %rsi
xorl %edx, %edx
movl %eax, %ecx
movq %r8, 0x10(%rsp)
callq 0xfbee
movq 0x10(%rsp), %r8
movq %rax, 0x9(%rbp,%r12)
movabsq $0x1ffffffffffffff8, %r12 # imm = 0x1FFFFFFFFFFFFFF8
pushq $0x40
popq %rax
movl %eax, %edx
subl %r8d, %edx
movl %r8d, %esi
leaq (%rbx,%r13), %rdi
decq %rdi
decq %rbx
cmpq %rbx, %r15
je 0xfb37
movq %rdi, %rcx
andq %r13, %rcx
movq 0x38(%r14), %r11
shlq $0x3, %r11
andq %r12, %r11
addq $0x11, %r11
imulq %r11, %rcx
movq 0x9(%rbp,%rcx), %r9
movq %rbx, %r10
andq %r13, %r10
imulq %r11, %r10
movq 0x9(%rbp,%r10), %r11
movl %edx, %ecx
shrq %cl, %r9
movl %esi, %ecx
shlq %cl, %r11
orq %r9, %r11
movq %r11, 0x9(%rbp,%r10)
decq %rdi
jmp 0xfaeb
movq 0x8(%rsp), %rdx
andq %r13, %r15
movq 0x38(%r14), %rbx
shlq $0x3, %rbx
andq %r12, %rbx
addq $0x11, %rbx
imulq %r15, %rbx
movq 0x9(%rbp,%rbx), %rsi
xorl %edi, %edi
movl %eax, %ecx
callq 0xfbee
movq %rax, 0x9(%rbp,%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: offset_lower_bound(quotient_filter const*, unsigned long)
static inline int offset_lower_bound(const QF *qf, uint64_t slot_index)
{
	const qfblock * b = get_block(qf, slot_index / SLOTS_PER_BLOCK);
	const uint64_t slot_offset = slot_index % SLOTS_PER_BLOCK;
	const uint64_t boffset = b->offset;
	const uint64_t occupieds = b->occupieds[0] & BITMASK(slot_offset+1);
	assert(SLOTS_PER_BLOCK == 64);
	if (boffset <= slot_offset) {
		const uint64_t runends = (b->runends[0] & BITMASK(slot_offset)) >> boffset;
		return popcnt(occupieds) - popcnt(runends);
	}
	return boffset - slot_offset + popcnt(occupieds);
}

// Assembly:
movq %rsi, %rcx
movq %rsi, %rax
shrq $0x6, %rax
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movabsq $0x3ffffffffffffff, %rdi # imm = 0x3FFFFFFFFFFFFFF
andq 0x38(%rdx), %rdi
leaq 0x11(,%rdi,8), %rdi
imulq %rax, %rdi
andl $0x3f, %ecx
pushq $0x2
popq %rax
shlq %cl, %rax
decq %rax
cmpq $0x3f, %rcx
pushq $-0x1
popq %r8
cmoveq %r8, %rax
movzbl (%rsi,%rdi), %edx
andq 0x1(%rsi,%rdi), %rax
cmpq %rcx, %rdx
jbe 0xfbd0
subl %ecx, %edx
popcntq %rax, %rax
addl %edx, %eax
retq
shlq %cl, %r8
notq %r8
andq 0x9(%rsi,%rdi), %r8
movl %edx, %ecx
shrq %cl, %r8
popcntq %rax, %rax
popcntq %r8, %r8
subl %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: shift_into_b(unsigned long, unsigned long, int, int, int)
static inline uint64_t shift_into_b(const uint64_t a, const uint64_t b,
																		const int bstart, const int bend,
																		const int amount)
{
	const uint64_t a_component = bstart == 0 ? (a >> (64 - amount)) : 0;
	const uint64_t b_shifted_mask = BITMASK(bend - bstart) << bstart;
	const uint64_t b_shifted = ((b_shifted_mask & b) << amount) & b_shifted_mask;
	const uint64_t b_mask = ~b_shifted_mask;
	return a_component | b_shifted | (b & b_mask);
}

// Assembly:
subl %edx, %ecx
pushq $-0x1
popq %r9
movq %r9, %rax
shlq %cl, %rax
cmpl $0x40, %ecx
notq %rax
cmoveq %r9, %rax
movl %r8d, %ecx
negb %cl
shrq %cl, %rdi
xorl %r9d, %r9d
testl %edx, %edx
cmoveq %rdi, %r9
movl %edx, %ecx
shlq %cl, %rax
movq %rax, %rdx
andq %rsi, %rdx
movl %r8d, %ecx
shlq %cl, %rdx
andq %rax, %rdx
notq %rax
andq %rsi, %rax
orq %r9, %rax
orq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: encode_counter(quotient_filter*, unsigned long, unsigned long, unsigned long*)
static inline uint64_t *encode_counter(QF *qf, uint64_t remainder, uint64_t
																			 counter, uint64_t *slots)
{
	uint64_t digit = remainder;
	uint64_t base = (1ULL << qf->metadata->bits_per_slot) - 1;
	uint64_t *p = slots;

	if (counter == 0)
		return p;

	*--p = remainder;

	if (counter == 1)
		return p;

	if (counter == 2) {
		*--p = remainder;
		return p;
	}

	if (counter == 3 && remainder == 0) {
		*--p = remainder;
		*--p = remainder;
		return p;    
	}

	if (counter == 3 && remainder > 0) {
		*--p = 0;
		*--p = remainder;
		return p;
	}

	if (remainder == 0)
		*--p = remainder;
	else 
		base--;

	if (remainder)
		counter -= 3;
	else
		counter -= 4;
	do {
		digit = counter % base;
		digit++; /* Zero not allowed */
		if (remainder && digit >= remainder)
			digit++; /* Cannot overflow since digit is mod 2^r-2 */
		*--p = digit;
		counter /= base;
	} while (counter);

	if (remainder && digit >= remainder)
		*--p = 0;

	*--p = remainder;

	return p;
}

// Assembly:
movq %rcx, %rax
movq 0x8(%rdi), %rcx
movb 0x38(%rcx), %cl
pushq $-0x1
popq %r8
shlq %cl, %r8
testq %rdx, %rdx
je 0xfd13
leaq -0x8(%rax), %rdi
movq %rsi, -0x8(%rax)
cmpq $0x1, %rdx
je 0xfc6d
cmpq $0x2, %rdx
jne 0xfc71
movq %rsi, -0x10(%rax)
addq $-0x10, %rax
retq
movq %rdi, %rax
retq
movq %rdx, %rcx
xorq $0x3, %rcx
orq %rsi, %rcx
jne 0xfc86
xorps %xmm0, %xmm0
movups %xmm0, -0x18(%rax)
jmp 0xfca2
cmpq $0x3, %rdx
setne %cl
testq %rsi, %rsi
sete %r9b
orb %cl, %r9b
jne 0xfca7
andq $0x0, -0x10(%rax)
movq %rsi, -0x18(%rax)
addq $-0x18, %rax
retq
testq %rsi, %rsi
je 0xfcba
pushq $-0x2
popq %rax
subq %r8, %rax
pushq $-0x3
popq %rcx
movq %rax, %r8
jmp 0xfccc
andq $0x0, -0x10(%rax)
notq %r8
addq $-0x10, %rax
pushq $-0x4
popq %rcx
movq %rax, %rdi
addq %rdx, %rcx
leaq -0x1(%rsi), %r9
movq %rcx, %rax
xorl %edx, %edx
divq %r8
leaq 0x1(%rdx), %r10
addq $0x2, %rdx
cmpq %r10, %r9
cmovaeq %r10, %rdx
movq %rdx, -0x8(%rdi)
addq $-0x8, %rdi
cmpq %rcx, %r8
movq %rax, %rcx
jbe 0xfcd3
cmpq %rdx, %r9
jae 0xfd08
andq $0x0, -0x8(%rdi)
pushq $-0x10
jmp 0xfd0a
pushq $-0x8
popq %rcx
leaq (%rdi,%rcx), %rax
movq %rsi, (%rdi,%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: shift_slots(quotient_filter*, long, unsigned long, unsigned long)
static inline void shift_slots(QF *qf, int64_t first, uint64_t last, uint64_t
															 distance)
{
	int64_t i;
	if (distance == 1)
		shift_remainders(qf, first, last+1);
	else
		for (i = last; i >= first; i--)
			set_slot(qf, i + distance, get_slot(qf, i));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x1, %rcx
jne 0x1003d
incq %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf91a
movq %rcx, %r12
cmpq %r14, %rbx
jl 0x10067
leaq (%r12,%rbx), %r13
movq %r15, %rdi
movq %rbx, %rsi
callq 0xf891
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xf826
decq %rbx
jmp 0x10040
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ewhitebloom[P]fetch/src/././header.cc
// Function: parseHeaders(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector <Header> parseHeaders(string headers) {
  vector<Header> headersVectorized;

  if (headers.length()) {
    vector <string> SplitVec;
    split( SplitVec, headers, boost::is_any_of("\n"), boost::token_compress_on );

    for (string& row : SplitVec) {
      size_t found = row.find(":");
      if (found != string::npos) {
        vector <string> ParsedRow;
        split( ParsedRow, row, boost::is_any_of(":"), boost::token_compress_on );

        struct Header header;
        header.header = ParsedRow[0];
        header.value = ParsedRow[1];
        headersVectorized.push_back(header);
      }
    }
  }

  return headersVectorized;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rdi, -0x30(%rbp)
movups %xmm0, (%rdi)
cmpq $0x0, 0x8(%rsi)
je 0x469a
movq %rsi, %rbx
movaps %xmm0, -0x70(%rbp)
andq $0x0, -0x60(%rbp)
leaq 0x3c07(%rip), %rsi      # 0x8184
leaq -0xc8(%rbp), %rdi
callq 0x541e
leaq -0x70(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5392
leaq -0xc8(%rbp), %rdi
callq 0x5450
movq -0x70(%rbp), %r14
movq -0x68(%rbp), %r15
leaq 0x3bcd(%rip), %r12      # 0x8186
leaq -0xe0(%rbp), %r13
leaq -0xb0(%rbp), %rbx
cmpq %r15, %r14
je 0x4691
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4030
cmpq $-0x1, %rax
je 0x4688
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
andq $0x0, -0x40(%rbp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x541e
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x5392
movq %r13, %rdi
callq 0x5450
leaq -0xa0(%rbp), %rax
movq %rax, -0xb0(%rbp)
andq $0x0, -0xa8(%rbp)
xorl %ecx, %ecx
movb %cl, -0xa0(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0x90(%rbp)
andq $0x0, -0x88(%rbp)
movb %cl, -0x80(%rbp)
movq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x4300
movq -0x50(%rbp), %rsi
addq $0x20, %rsi
leaq -0x90(%rbp), %rdi
callq 0x4300
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x546c
movq %rbx, %rdi
callq 0x54a8
leaq -0x50(%rbp), %rdi
callq 0x54c8
addq $0x20, %r14
jmp 0x45c7
leaq -0x70(%rbp), %rdi
callq 0x54c8
movq -0x30(%rbp), %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x5450
jmp 0x46f4
movq %rax, %rbx
jmp 0x46f4
movq %rax, %rbx
jmp 0x46eb
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0x5450
jmp 0x46eb
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x54a8
leaq -0x50(%rbp), %rdi
callq 0x54c8
leaq -0x70(%rbp), %rdi
callq 0x54c8
movq -0x30(%rbp), %rdi
callq 0x54f4
movq %rbx, %rdi
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/ewhitebloom[P]fetch/src/././request/get.cc
// Function: get::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Response get(string& url) {
    CURL* curl;
    CURLcode res;
    curl_global_init(CURL_GLOBAL_ALL);
    curl = curl_easy_init();

    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &writeCallback);
    curl_easy_setopt(curl, CURLOPT_HEADER, 1L);
    curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, header_callback);

    res = curl_easy_perform(curl);

    curl_easy_cleanup(curl);
    curl_global_cleanup();

    Response response;
    response.url = url;
    response.body = fetchResponse;

    if (res != CURLE_OK) {
      raiseCurlCode(res);
    } else {
      int response_code;
      curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);

      response.status = response_code;
      response.headers = parseHeaders(headers);
    }

    return response;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x3
popq %rdi
callq 0x40c0
callq 0x42a0
movq %rax, %r14
movq (%r15), %rdx
movq %rax, %rdi
movl $0x2712, %esi           # imm = 0x2712
xorl %eax, %eax
callq 0x4230
leaq -0x80(%rip), %rdx       # 0x4b9b
movq %r14, %rdi
movl $0x4e2b, %esi           # imm = 0x4E2B
xorl %eax, %eax
callq 0x4230
pushq $0x2a
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x4230
leaq 0xe5(%rip), %rdx        # 0x4d26
movq %r14, %rdi
movl $0x4e6f, %esi           # imm = 0x4E6F
xorl %eax, %eax
callq 0x4230
movq %r14, %rdi
callq 0x41b0
movl %eax, %r12d
movq %r14, %rdi
callq 0x4090
callq 0x4280
movq %rbx, %rdi
callq 0x5520
leaq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0x4300
leaq 0x9535(%rip), %rsi      # 0xe1b8
movq %rbx, %rdi
callq 0x4300
testl %r12d, %r12d
je 0x4c9a
movl %r12d, %edi
callq 0x470e
jmp 0x4cf1
leaq -0x24(%rbp), %rdx
movq %r14, %rdi
movl $0x200002, %esi         # imm = 0x200002
xorl %eax, %eax
callq 0x4290
movl -0x24(%rbp), %eax
movl %eax, 0x20(%rbx)
leaq 0x951e(%rip), %rsi      # 0xe1d8
leaq -0x48(%rbp), %rdi
callq 0x4140
leaq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x453c
leaq 0x68(%rbx), %rdi
leaq -0x60(%rbp), %r14
movq %r14, %rsi
callq 0x7ad0
movq %r14, %rdi
callq 0x54f4
leaq -0x48(%rbp), %rdi
callq 0x4330
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x4330
jmp 0x4d16
jmp 0x4d13
jmp 0x4d13
movq %rax, %r14
movq %rbx, %rdi
callq 0x5564
movq %r14, %rdi
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/ewhitebloom[P]fetch/src/././request/../encode/encode.cc
// Function: encode(std::vector<Param<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<Param<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
string encode(vector < Param <string> >& params) {
  string result = "";
  for (auto& param : params) {
    result += encode(param);
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x3122(%rip), %rsi      # 0x8185
leaq -0x40(%rbp), %r14
movq %r14, %rdx
callq 0x42b0
movq (%r12), %r15
movq 0x8(%r12), %r12
cmpq %r12, %r15
je 0x50a1
movq %r14, %rdi
movq %r15, %rsi
callq 0x4d68
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4220
movq %r14, %rdi
callq 0x4330
addq $0x40, %r15
jmp 0x5078
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x50c2
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x4330
movq %rbx, %rdi
callq 0x4330
movq %r14, %rdi
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/ewhitebloom[P]fetch/src/././request/post.cc
// Function: post::post(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<Param<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<Param<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
Response post(string& url, vector< Param<string> >& params) {
    CURL *curl;
    CURLcode res;

    curl_global_init(CURL_GLOBAL_ALL);

    curl = curl_easy_init();

    Response response;
    response.url = url;
    response.body = fetchResponse;

    if (curl) {
      curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
      curl_easy_setopt(curl, CURLOPT_POSTFIELDS, encode(params).c_str());

      res = curl_easy_perform(curl);

      if (res != CURLE_OK) {
        raiseCurlCode(res);
      } else {
        int response_code;
        curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);

        response.status = response_code;
        response.headers = parseHeaders(headers);
      }

      curl_easy_cleanup(curl);
    }
    curl_global_cleanup();

    return response;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x3
popq %rdi
callq 0x40c0
callq 0x42a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5520
leaq 0x28(%rbx), %rdi
movq %r12, %rsi
callq 0x4300
leaq 0x90a1(%rip), %rsi      # 0xe1f8
movq %rbx, %rdi
callq 0x4300
testq %r14, %r14
je 0x5217
movq (%r12), %rdx
movq %r14, %rdi
movl $0x2712, %esi           # imm = 0x2712
xorl %eax, %eax
callq 0x4230
leaq -0x48(%rbp), %rdi
movq %r15, %rsi
callq 0x5047
movq -0x48(%rbp), %rdx
movq %r14, %rdi
movl $0x271f, %esi           # imm = 0x271F
xorl %eax, %eax
callq 0x4230
leaq -0x48(%rbp), %rdi
callq 0x4330
movq %r14, %rdi
callq 0x41b0
testl %eax, %eax
je 0x51b8
movl %eax, %edi
callq 0x470e
jmp 0x520f
leaq -0x24(%rbp), %rdx
movq %r14, %rdi
movl $0x200002, %esi         # imm = 0x200002
xorl %eax, %eax
callq 0x4290
movl -0x24(%rbp), %eax
movl %eax, 0x20(%rbx)
leaq 0x9040(%rip), %rsi      # 0xe218
leaq -0x68(%rbp), %rdi
callq 0x4140
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x453c
leaq 0x68(%rbx), %rdi
leaq -0x48(%rbp), %r15
movq %r15, %rsi
callq 0x7ad0
movq %r15, %rdi
callq 0x54f4
leaq -0x68(%rbp), %rdi
callq 0x4330
movq %r14, %rdi
callq 0x4090
callq 0x4280
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x68(%rbp), %rdi
jmp 0x5240
jmp 0x5249
jmp 0x5249
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x4330
jmp 0x524c
jmp 0x5249
movq %rax, %r14
movq %rbx, %rdi
callq 0x5564
movq %r14, %rdi
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/ewhitebloom[P]fetch/src/./fetch.cc
// Function: Fetch::fetch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Param<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<Param<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>)
Response fetch(string url, string method, vector< Param<string> > params) {
    if (method == "GET") {
      return get::get(url);
    } else if (method == "POST") {
      return post::post(url, params);
    } else {
      return get::get(url);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2ef8(%rip), %rsi      # 0x818a
movq %rdx, %rdi
callq 0x5724
testb %al, %al
jne 0x52c1
leaq 0x2ee9(%rip), %rsi      # 0x818e
movq %r12, %rdi
callq 0x5724
testb %al, %al
je 0x52c1
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5114
jmp 0x52cc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4bdd
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ewhitebloom[P]fetch/src/main.cc
// Function: main
int main () {

  // Response res = fetch("https://www.google.com");
  //
  // cout << "Status: " << res.status << endl;
  //
  // for (auto& header : res.headers) {
  //   cout << header.header << ": " << header.value << endl;
  // }
  //
  // Response response = fetch("https://www.nytimes.com");
  //
  // for (auto& header : response.headers) {
  //   cout << header.header << ": " << header.value << endl;
  // }


  Response r = fetch("https://www.google.com");

  if (r.ok()) {
    cout << r.body << endl;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xa8, %rsp
leaq 0x2e90(%rip), %rsi      # 0x8193
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x42b0
leaq -0xb0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4bdd
leaq -0x30(%rbp), %rdi
callq 0x4330
cmpl $0xc8, -0x90(%rbp)
jne 0x5350
movq 0x8c94(%rip), %rdi      # 0xdfd0
leaq -0xb0(%rbp), %rsi
callq 0x40d0
movq %rax, %rdi
callq 0x42c0
leaq -0xb0(%rbp), %rdi
callq 0x5564
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x5564
jmp 0x538a
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4330
jmp 0x538a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/dgboy2000[P]compress/compress.cpp
// Function: DATCompression::identity_compress(std::vector<int, std::allocator<int>>)
vector<int> DATCompression::identity_compress(vector<int> data) {
    vector<int> compressed;
    compressed.push_back(data[0]);
    compressed.push_back(data[1]);
    compressed.push_back(data[2]);
    
    vector<int>::iterator viter = data.begin();
    viter++;
    viter++;
    viter++;
    for (viter; viter != data.end(); ++viter) {
        int val = *viter;
        
        compressed.push_back(val / 256);
        compressed.push_back(val % 256);
    }
    
    return compressed;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rdx), %rsi
callq 0x51de
movq (%r14), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
callq 0x51de
movq (%r14), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x51de
movq (%r14), %r13
addq $0xc, %r13
leaq 0x4(%rsp), %r15
movq %rsp, %r12
cmpq 0x8(%r14), %r13
je 0x2484
movl (%r13), %eax
cltd
movl $0x100, %ecx            # imm = 0x100
idivl %ecx
movl %edx, %ebp
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5602
movl %ebp, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5602
addq $0x4, %r13
jmp 0x244d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x249a
jmp 0x249a
movq %rax, %r14
movq %rbx, %rdi
callq 0x5466
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dgboy2000[P]compress/compress.cpp
// Function: DATCompression::identity_decompress(std::vector<int, std::allocator<int>>)
vector<int> DATCompression::identity_decompress(vector<int> compressed) {
    vector<int> decompressed;
    decompressed.push_back(compressed[0]);
    decompressed.push_back(compressed[1]);
    decompressed.push_back(compressed[2]);
    
    vector<int>::iterator viter = compressed.begin();
    viter++;
    viter++;
    viter++;
    for (viter; viter != compressed.end(); ++viter) {
        int val = *viter;
        val = 256 * val + *(++viter);
        
        decompressed.push_back(val);
    }
    
    return decompressed;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rdx), %rsi
callq 0x51de
movq (%r14), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
callq 0x51de
movq (%r14), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x51de
movq (%r14), %r12
addq $0xc, %r12
leaq 0x4(%rsp), %r15
cmpq 0x8(%r14), %r12
je 0x2520
movl (%r12), %eax
shll $0x8, %eax
addl 0x4(%r12), %eax
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51de
addq $0x8, %r12
jmp 0x24f9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2531
movq %rax, %r14
movq %rbx, %rdi
callq 0x5466
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/dgboy2000[P]compress/compress.cpp
// Function: DATCompression::compression(std::vector<int, std::allocator<int>>)
vector <int> DATCompression::compression(vector<int> data)
{
    vector <int> compressed = data;
    int i, n=30;
  
    // // Simple compression stack
    // compressed = diff_compress(data);
    // compressed = huffman_compress(compressed);

    // bzip-inspired compression stack (but simpler)
    compressed = diff_compress(compressed);
    compressed = run_length_encode(compressed);
    compressed = burrows_wheeler_encode(compressed);
    compressed = run_length_encode(compressed);
    compressed = golomb_compress(compressed);
    compressed = huffman_compress(compressed);

    return compressed;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x51fc
leaq 0x98(%rsp), %rdi
movq %rbx, %rsi
callq 0x51fc
leaq 0x8(%rsp), %rdi
leaq 0x98(%rsp), %rdx
callq 0x275c
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56f8
movq %r15, %rdi
callq 0x5466
leaq 0x98(%rsp), %rdi
callq 0x5466
leaq 0x80(%rsp), %rdi
movq %rbx, %rsi
callq 0x51fc
leaq 0x8(%rsp), %rdi
leaq 0x80(%rsp), %rdx
callq 0x2958
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56f8
movq %r15, %rdi
callq 0x5466
leaq 0x80(%rsp), %rdi
callq 0x5466
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
callq 0x51fc
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x2a58
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56f8
movq %r15, %rdi
callq 0x5466
leaq 0x68(%rsp), %rdi
callq 0x5466
leaq 0x50(%rsp), %rdi
movq %rbx, %rsi
callq 0x51fc
leaq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x2958
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56f8
movq %r15, %rdi
callq 0x5466
leaq 0x50(%rsp), %rdi
callq 0x5466
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x51fc
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rdx
movq %r14, %rsi
callq 0x2b52
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56f8
movq %r14, %rdi
callq 0x5466
leaq 0x38(%rsp), %rdi
callq 0x5466
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x51fc
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x2d0e
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56f8
movq %r14, %rdi
callq 0x5466
leaq 0x20(%rsp), %rdi
callq 0x5466
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0x2741
jmp 0x2748
movq %rax, %r14
leaq 0x38(%rsp), %rdi
jmp 0x2741
jmp 0x2748
movq %rax, %r14
leaq 0x50(%rsp), %rdi
jmp 0x2741
jmp 0x2748
movq %rax, %r14
leaq 0x68(%rsp), %rdi
jmp 0x2741
jmp 0x2748
movq %rax, %r14
leaq 0x80(%rsp), %rdi
jmp 0x2741
jmp 0x2748
movq %rax, %r14
leaq 0x98(%rsp), %rdi
callq 0x5466
jmp 0x274b
movq %rax, %r14
movq %rbx, %rdi
callq 0x5466
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dgboy2000[P]compress/compress.cpp
// Function: DATCompression::burrows_wheeler_encode(std::vector<int, std::allocator<int>>)
vector<int> DATCompression::burrows_wheeler_encode(vector<int> data) {
    int n = data.size();
    SuffixArray sa(&data);
    
    vector<int> bwt;
    bwt.resize(n+4);
    vector<int>::iterator bwt_iter = bwt.begin();
    
    long int dollar_ind;
    *(bwt_iter++) = data.back();
    
    for (int i=0; i<n; ++i) {
        if (sa[i] == 0) {
            *(bwt_iter++) = 0;
            dollar_ind = i + 1;
        }
        else *(bwt_iter++) = data[sa[i] - 1];
    }
    
    *(bwt_iter++) = dollar_ind / (256*256);
    *(bwt_iter++) = (dollar_ind / 256) % 256;
    *(bwt_iter++) = dollar_ind % 256;
    
    return bwt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %r15
subq (%rdx), %r15
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x471e
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %r15, %rax
shlq $0x1e, %rax
movabsq $0x400000000, %rsi      # imm = 0x400000000
addq %rax, %rsi
sarq $0x20, %rsi
movq %rbx, %rdi
callq 0x5300
shrq $0x2, %r15
movq (%rbx), %rsi
movq 0x8(%r14), %rax
movl -0x4(%rax), %eax
movl %eax, (%rsi)
movq 0x10(%rsp), %rax
xorl %edx, %edx
testl %r15d, %r15d
cmovlel %edx, %r15d
addq $0x4, %rsi
cmpq %r15, %rdx
je 0x2af3
movslq (%rax,%rdx,4), %rdi
testq %rdi, %rdi
je 0x2ae3
movq (%r14), %r8
movl -0x4(%r8,%rdi,4), %edi
incq %rdx
jmp 0x2aeb
incq %rdx
xorl %edi, %edi
movq %rdx, %rcx
movl %edi, (%rsi)
addq $0x4, %rsi
jmp 0x2ac8
movl $0x10000, %edi          # imm = 0x10000
movq %rcx, %rax
cqto
idivq %rdi
movl %eax, (%rsi)
movl $0x100, %edi            # imm = 0x100
movq %rcx, %rax
cqto
idivq %rdi
movq %rdx, %rcx
cqto
idivq %rdi
movl %edx, 0x4(%rsi)
movl %ecx, 0x8(%rsi)
leaq 0x8(%rsp), %rdi
callq 0x52e8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5466
leaq 0x8(%rsp), %rdi
callq 0x52e8
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dgboy2000[P]compress/compress.cpp
// Function: DATCompression::decompression(std::vector<int, std::allocator<int>>)
vector <int> DATCompression::decompression(vector<int> compressed)
{
  vector <int> decompressed = compressed;
  int i,n=30;
  
  // // Simple decompression stack
  // decompressed = huffman_decompress(decompressed);
  // decompressed = diff_decompress(decompressed);

  // bzip-inspired decompression stack (but simpler)
  decompressed = huffman_decompress(decompressed);
  decompressed = golomb_decompress(decompressed);
  decompressed = run_length_decode(decompressed);
  decompressed = burrows_wheeler_decode(decompressed);
  decompressed = run_length_decode(decompressed);
  decompressed = diff_decompress(decompressed);

  return decompressed;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x51fc
leaq 0x98(%rsp), %rdi
movq %rbx, %rsi
callq 0x51fc
leaq 0x8(%rsp), %rdi
leaq 0x98(%rsp), %rdx
callq 0x33c8
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56f8
movq %r15, %rdi
callq 0x5466
leaq 0x98(%rsp), %rdi
callq 0x5466
leaq 0x80(%rsp), %rdi
movq %rbx, %rsi
callq 0x51fc
leaq 0x8(%rsp), %rdi
leaq 0x80(%rsp), %rdx
movq %r14, %rsi
callq 0x36f0
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56f8
movq %r14, %rdi
callq 0x5466
leaq 0x80(%rsp), %rdi
callq 0x5466
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
callq 0x51fc
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x384e
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56f8
movq %r14, %rdi
callq 0x5466
leaq 0x68(%rsp), %rdi
callq 0x5466
leaq 0x50(%rsp), %rdi
movq %rbx, %rsi
callq 0x51fc
leaq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x390a
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56f8
movq %r14, %rdi
callq 0x5466
leaq 0x50(%rsp), %rdi
callq 0x5466
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x51fc
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x384e
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56f8
movq %r14, %rdi
callq 0x5466
leaq 0x38(%rsp), %rdi
callq 0x5466
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x51fc
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x3a82
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56f8
movq %r14, %rdi
callq 0x5466
leaq 0x20(%rsp), %rdi
callq 0x5466
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0x33ad
jmp 0x33b4
movq %rax, %r14
leaq 0x38(%rsp), %rdi
jmp 0x33ad
jmp 0x33b4
movq %rax, %r14
leaq 0x50(%rsp), %rdi
jmp 0x33ad
jmp 0x33b4
movq %rax, %r14
leaq 0x68(%rsp), %rdi
jmp 0x33ad
jmp 0x33b4
movq %rax, %r14
leaq 0x80(%rsp), %rdi
jmp 0x33ad
jmp 0x33b4
movq %rax, %r14
leaq 0x98(%rsp), %rdi
callq 0x5466
jmp 0x33b7
movq %rax, %r14
movq %rbx, %rdi
callq 0x5466
movq %r14, %rdi
callq 0x22a0
nop