LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: qf_read
void qf_read(QF *qf, const char *path)
{
	struct stat sb;
	int ret;

	qf->mem = (qfmem *)calloc(sizeof(qfmem), 1);
	qf->mem->fd = open(path, O_RDWR, S_IRWXU);
	if (qf->mem->fd < 0) {
		perror("Couldn't open file:\n");
		exit(EXIT_FAILURE);
	}

	ret = fstat (qf->mem->fd, &sb);
	if ( ret < 0) {
		perror ("fstat");
		exit(EXIT_FAILURE);
	}

	if (!S_ISREG (sb.st_mode)) {
		fprintf (stderr, "%s is not a file\n", path);
		exit(EXIT_FAILURE);
	}

	qf->metadata = (qfmetadata *)mmap(NULL, sb.st_size, PROT_READ | PROT_WRITE, MAP_SHARED,
																qf->mem->fd, 0);

	qf->blocks = (qfblock *)(qf->metadata + sizeof(qfmetadata));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x18, %edi
movl $0x1, %esi
callq 0x2130
movq %rax, (%rbx)
movq %r14, %rdi
movl $0x2, %esi
movl $0x1c0, %edx            # imm = 0x1C0
xorl %eax, %eax
callq 0x2190
movq (%rbx), %rcx
movl %eax, (%rcx)
testl %eax, %eax
js 0x1001a
leaq 0x8(%rsp), %rsi
movl %eax, %edi
callq 0x23a0
testl %eax, %eax
js 0x1001f
movl $0xf000, %eax           # imm = 0xF000
andl 0x20(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x10024
movq 0x38(%rsp), %rsi
movq (%rbx), %rax
movl (%rax), %r8d
xorl %edi, %edi
movl $0x3, %edx
movl $0x1, %ecx
xorl %r9d, %r9d
callq 0x23c0
movq %rax, 0x8(%rbx)
addq $0x4000, %rax           # imm = 0x4000
movq %rax, 0x10(%rbx)
addq $0x98, %rsp
popq %rbx
popq %r14
retq
callq 0x24e7
callq 0x24d2
movq %r14, %rdi
callq 0x24ae
// File: /workspace/github_cpp_makefile_star2_O3/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: qf_serialize
void qf_serialize(const QF *qf, const char *filename)
{
	FILE *fout;
	fout = fopen(filename, "wb+");
	if (fout == NULL) {
		perror("Error opening file for serializing\n");
		exit(EXIT_FAILURE);
	}

	fwrite(qf->metadata, sizeof(qfmetadata), 1, fout);

	/* we don't serialize the locks */
	fwrite(qf->blocks, qf->metadata->size, 1, fout);

	fclose(fout);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %r14
leaq 0x4a6e(%rip), %rsi      # 0x14ae4
movq %rax, %rdi
callq 0x22a0
testq %rax, %rax
je 0x100c3
movq %rax, %rbx
movq 0x8(%r14), %rdi
movl $0x80, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x2410
movq 0x8(%r14), %rax
movq 0x10(%r14), %rdi
movq (%rax), %rsi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2410
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2230
callq 0x24fc
// File: /workspace/github_cpp_makefile_star2_O3/splatlab[P]debgr/threadsafe-gqf/gqf.c
// Function: qf_deserialize
void qf_deserialize(QF *qf, const char *filename)
{
	FILE *fin;
	fin = fopen(filename, "rb");
	if (fin == NULL) {
		perror("Error opening file for deserializing\n");
		exit(EXIT_FAILURE);
	}

	qf->mem = (qfmem *)calloc(sizeof(qfmem), 1);
	qf->metadata = (qfmetadata *)calloc(sizeof(qfmetadata), 1);

	fread(qf->metadata, sizeof(qfmetadata), 1, fin);

	/* initlialize the locks in the QF */
	qf->metadata->num_locks = (qf->metadata->xnslots/NUM_SLOTS_TO_LOCK)+2;
	qf->mem->metadata_lock = 0;
	/* initialize all the locks to 0 */
	qf->mem->locks = (volatile int *)calloc(qf->metadata->num_locks, sizeof(volatile int));

	qf->blocks = (qfblock *)calloc(qf->metadata->size, 1);
	fread(qf->blocks, qf->metadata->size, 1, fin);

	fclose(fin);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %r14
leaq 0x4a2f(%rip), %rsi      # 0x14b0c
movq %rax, %rdi
callq 0x22a0
testq %rax, %rax
je 0x10194
movq %rax, %rbx
movl $0x18, %edi
movl $0x1, %esi
callq 0x2130
movq %rax, (%r14)
movl $0x80, %edi
movl $0x1, %esi
callq 0x2130
movq %rax, 0x8(%r14)
movl $0x80, %esi
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rcx
callq 0x2340
movq 0x8(%r14), %r15
movq 0x18(%r15), %rdi
shrq $0xc, %rdi
addq $0x2, %rdi
movq %rdi, 0x70(%r15)
movq (%r14), %r12
movl $0x0, 0x4(%r12)
movl $0x4, %esi
callq 0x2130
movq %rax, 0x8(%r12)
movq (%r15), %r15
movl $0x1, %esi
movq %r15, %rdi
callq 0x2130
movq %rax, 0x10(%r14)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x2340
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2230
callq 0x2511
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8(%rdi), %rbx
movq 0x38(%rbx), %rcx
movq $-0x1, %r12
shlq %cl, %r12
movq $-0x1, %rax
cmpq $0x40, %rcx
notq %r12
cmoveq %rax, %r12
movq %rsi, %rbp
xorl %eax, %eax
movq %rsi, %r15
shrdq %cl, %rax, %r15
movq 0x10(%rdi), %r14
testb $0x40, %cl
cmovneq %rax, %r15
movq %r15, %rsi
shrq $0x6, %rsi
movabsq $0x3ffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFF
andq %rcx, %rdx
leaq 0x11(,%rdx,8), %r13
imulq %r13, %rsi
movq 0x1(%r14,%rsi), %rdx
btq %r15, %rdx
jae 0x121ae
testq %r15, %r15
je 0x1215d
leaq -0x1(%r15), %rdx
movq %rcx, %rdi
movq %r14, %rsi
callq 0x121bd
incq %rax
jmp 0x1215f
xorl %eax, %eax
andq %rbp, %r12
cmpq %r15, %rax
cmovgq %rax, %r15
leaq 0x8(%rsp), %rbp
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
leaq 0x10(%rsp), %rcx
movq %rbp, %r8
callq 0x12480
cmpq %r12, 0x10(%rsp)
je 0x121a9
leaq 0x1(%rax), %r15
movq %rax, %rcx
shrq $0x6, %rcx
imulq %r13, %rcx
movq 0x9(%r14,%rcx), %rcx
btq %rax, %rcx
jae 0x1216e
xorl %eax, %eax
jmp 0x121ae
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
movq 0x10(%rdi), %rdx
movq 0x8(%rax), %r13
movq 0x10(%rax), %rsi
leaq 0x10(%rsp), %rbp
leaq 0x8(%rsp), %r8
movq %r13, %rdi
movq %rbp, %rcx
callq 0x12480
movq 0x8(%r12), %rax
movb 0x38(%r13), %cl
shlq %cl, %rax
orq (%rbp), %rax
movq %rax, (%r15)
movq $0x0, (%r14)
leaq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, %xmm0
movq %rax, (%rbx)
shufpd $0x2, 0x2028(%rip), %xmm0 # xmm0 = xmm0[0],mem[1]
movdqu 0x58(%r13), %xmm1
paddq %xmm1, %xmm0
movdqu %xmm0, 0x58(%r13)
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_O3/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 0x12766
leaq 0x38(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x12766
leaq 0x18(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
callq 0x129d7
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %r12
movq %r13, %rdi
movq %r12, %rcx
callq 0x129d7
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rax
cmpq %rax, %rsi
jae 0x12de6
movq 0x10(%rsp), %rcx
movq %rbx, %rdi
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x10199
movq %r14, %rdi
callq 0x12a69
movq %r14, %rdi
leaq 0x18(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
jmp 0x12e1a
movq 0x20(%rsp), %rcx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x10199
movq %r13, %rdi
callq 0x12a69
movq %r13, %rdi
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %r12, %rcx
callq 0x129d7
movq 0x68(%rsp), %rax
movq 0x78(%rsp), %rcx
movq 0x8(%rax), %rax
movq 0x38(%rsp), %r15
movq 0x48(%rsp), %rbp
cmpq 0x18(%rax), %rcx
jae 0x12e97
movq 0x8(%r15), %rax
cmpq 0x18(%rax), %rbp
jb 0x12da2
leaq 0x68(%rsp), %r14
leaq 0x30(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r14, %rdi
leaq 0x18(%rsp), %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x129d7
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rcx
movq %rbx, %rdi
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x10199
movq %r14, %rdi
callq 0x12a69
testl %eax, %eax
je 0x12e5a
movq 0x8(%r15), %rax
cmpq 0x18(%rax), %rbp
jae 0x12ef0
leaq 0x38(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
leaq 0x20(%rsp), %r13
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x129d7
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rcx
movq %rbx, %rdi
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x10199
movq %r14, %rdi
callq 0x12a69
testl %eax, %eax
je 0x12eb5
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15d, %r15d
leaq 0x18(%rsp), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x12766
leaq 0x10(%rsp), %r12
movq %rsp, %rbp
xorl %r13d, %r13d
movq %r15, 0x8(%rsp)
movq %r15, (%rsp)
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x129d7
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x120d0
imulq (%rsp), %rax
addq %rax, %r13
movq %r14, %rdi
callq 0x12a69
testl %eax, %eax
je 0x1317e
movq %r13, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r8
cmpq $0x1, %rcx
jne 0x138ec
movabsq $0x1ffffffffffffff8, %rbx # imm = 0x1FFFFFFFFFFFFFF8
addq $0x2, %r8
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r10
movq 0x38(%r14), %r9
imulq %r9, %r8
movq %r8, %rcx
shrq $0x6, %rcx
imulq %r9, %rsi
movq %rsi, %rdi
shrq $0x6, %rdi
andl $0x3f, %r8d
cmpq %rdi, %rcx
jne 0x139be
movq %rcx, %rdi
jmp 0x13a6b
cmpq %rsi, %r8
jl 0x13ad4
movq %rcx, %rax
movabsq $0x1ffffffffffffff8, %r9 # imm = 0x1FFFFFFFFFFFFFF8
movq 0x8(%rdi), %r10
movq 0x10(%rdi), %r11
addq $0x11, %r11
movq $-0x1, %rbx
movq 0x38(%r10), %rdx
movq %r8, %rcx
shrq $0x6, %rcx
leaq (,%rdx,8), %r14
andq %r9, %r14
addq $0x11, %r14
imulq %r14, %rcx
addq %r11, %rcx
movl %r8d, %edi
andl $0x3f, %edi
imulq %rdx, %rdi
movq %rdi, %r15
shrq $0x3, %r15
movq (%r15,%rcx), %r15
movq $-0x1, %r12
movl %edx, %ecx
shlq %cl, %r12
cmpq $0x40, %rdx
notq %r12
cmoveq %rbx, %r12
andb $0x7, %dil
movl %edi, %ecx
shrq %cl, %r15
leaq (%rax,%r8), %rcx
andq %r12, %r15
movl %ecx, %edi
andl $0x3f, %edi
imulq %rdx, %rdi
imull %ecx, %edx
movq %rcx, %r13
shrq $0x6, %r13
imulq %r14, %r13
addq %r11, %r13
shrq $0x3, %rdi
andb $0x7, %dl
movl %edx, %ecx
shlq %cl, %r12
shlq %cl, %r15
notq %r12
andq (%rdi,%r13), %r12
orq %r15, %r12
movq %r12, (%rdi,%r13)
leaq -0x1(%r8), %rcx
cmpq %rsi, %r8
movq %rcx, %r8
jg 0x13915
jmp 0x13ad4
movq %r10, -0x8(%rsp)
leaq 0x11(%r10), %r15
movq $-0x1, %r12
leaq -0x1(%rcx), %r9
movq 0x38(%r14), %r10
movq %r9, %rax
xorl %edx, %edx
divq %r10
leaq (,%r10,8), %rbp
andq %rbx, %rbp
addq $0x11, %rbp
imulq %rbp, %rax
addq %r15, %rax
movq (%rax,%rdx,8), %r13
movq %rcx, %rax
xorl %edx, %edx
divq %r10
imulq %rbp, %rax
addq %r15, %rax
movq $-0x1, %rbp
movl %r8d, %ecx
shlq %cl, %rbp
cmpl $0x40, %r8d
notq %rbp
cmoveq %r12, %rbp
movl %r10d, %ecx
negb %cl
shrq %cl, %r13
movq (%rax,%rdx,8), %r11
movq %r11, %r8
andq %rbp, %r8
movl %r10d, %ecx
shlq %cl, %r8
andq %rbp, %r8
notq %rbp
andq %r11, %rbp
orq %r13, %rbp
orq %r8, %rbp
movq %rbp, (%rax,%rdx,8)
movl $0x40, %r8d
movq %r9, %rcx
cmpq %r9, %rdi
jne 0x139ce
movq 0x38(%r14), %r9
movl $0x40, %r8d
movq -0x8(%rsp), %r10
movq %rdi, %rax
xorl %edx, %edx
divq %r9
leaq (,%r9,8), %rcx
andq %rbx, %rcx
movl %esi, %edi
andl $0x3f, %edi
addq $0x11, %rcx
imulq %rcx, %rax
addq %rax, %r10
subl %edi, %r8d
movq $-0x1, %rax
movq $-0x1, %rdi
movl %r8d, %ecx
shlq %cl, %rdi
cmpl $0x40, %r8d
notq %rdi
cmoveq %rax, %rdi
movl %esi, %ecx
shlq %cl, %rdi
movq 0x11(%r10,%rdx,8), %rax
movq %rdi, %rsi
andq %rax, %rsi
movl %r9d, %ecx
shlq %cl, %rsi
xorq %rax, %rsi
andq %rdi, %rsi
xorq %rax, %rsi
movq %rsi, 0x11(%r10,%rdx,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x3a25(%rip), %rdx      # 0x9181
movq %rdx, %rsi
callq 0x6666
movq (%r15), %r14
movq 0x8(%r15), %r12
cmpq %r12, %r14
je 0x57aa
leaq -0x40(%rbp), %r13
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4ee3
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x41d0
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x57a1
callq 0x4130
addq $0x40, %r14
cmpq %r12, %r14
jne 0x5778
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x57d2
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x57d2
callq 0x4130
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x57e0
callq 0x4130
movq %r14, %rdi
callq 0x4180
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3744(%rip), %rsi      # 0x9186
movq %rdx, %rdi
callq 0x4240
testl %eax, %eax
je 0x5a61
leaq 0x3735(%rip), %rsi      # 0x918a
movq %r12, %rdi
callq 0x4240
testl %eax, %eax
je 0x5a6e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4cc2
jmp 0x5a7c
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x582d
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0xa0, %rsp
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x36d2(%rip), %rsi      # 0x918f
leaq 0x36e1(%rip), %rdx      # 0x91a5
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x6666
leaq -0xb0(%rbp), %rdi
movq %rbx, %rsi
callq 0x4cc2
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x5aed
callq 0x4130
cmpl $0xc8, -0x90(%rbp)
jne 0x5b3d
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq 0x84c2(%rip), %rdi      # 0xdfd0
callq 0x4280
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4140
movq %rax, %rdi
callq 0x4120
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x5e02
movq -0x20(%rbx), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x5b5b
callq 0x4130
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5b6d
callq 0x4130
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5b82
callq 0x4130
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x5bb2
callq 0x4130
jmp 0x5bb2
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x5e36
movq %rbx, %rdi
callq 0x4180
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rdx
xorl %esi, %esi
callq 0x652a
movq (%r14), %r13
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
leaq 0x4(%r13), %rdx
cmpq %rax, %rsi
je 0x2477
movl (%rdx), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x248a
movq %rbx, %rdi
callq 0x652a
movq (%r14), %r13
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
leaq 0x8(%r13), %rdx
cmpq %rax, %rsi
je 0x24a1
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x24ac
movq %rbx, %rdi
callq 0x652a
movq (%r14), %r13
addq $0xc, %r13
cmpq 0x8(%r14), %r13
je 0x2535
movq %rsp, %r12
movl (%r13), %ebp
leal 0xff(%rbp), %r15d
testl %ebp, %ebp
cmovnsl %ebp, %r15d
movl %r15d, %ecx
sarl $0x8, %ecx
movl %ecx, 0x4(%rsp)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
cmpq %rax, %rsi
je 0x24ed
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2502
movq %rbx, %rdi
leaq 0x4(%rsp), %rdx
callq 0x664a
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
andl $0xffffff00, %r15d      # imm = 0xFFFFFF00
subl %r15d, %ebp
movl %ebp, (%rsp)
cmpq %rax, %rsi
je 0x2520
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x252b
movq %rbx, %rdi
movq %r12, %rdx
callq 0x664a
addq $0x4, %r13
cmpq 0x8(%r14), %r13
jne 0x24b9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x254b
jmp 0x254b
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2562
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rdx
xorl %esi, %esi
callq 0x652a
movq (%r14), %r12
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
leaq 0x4(%r12), %rdx
cmpq %rax, %rsi
je 0x25b3
movl (%rdx), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x25c6
movq %rbx, %rdi
callq 0x652a
movq (%r14), %r12
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
leaq 0x8(%r12), %rdx
cmpq %rax, %rsi
je 0x25de
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x25e9
movq %rbx, %rdi
callq 0x652a
movq (%r14), %r12
addq $0xc, %r12
movq 0x8(%r14), %rax
cmpq %rax, %r12
je 0x2639
leaq 0x4(%rsp), %r15
movl (%r12), %ecx
shll $0x8, %ecx
addl 0x4(%r12), %ecx
movl %ecx, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2621
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2630
movq %rbx, %rdi
movq %r15, %rdx
callq 0x652a
movq 0x8(%r14), %rax
addq $0x8, %r12
cmpq %rax, %r12
jne 0x25fb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x264a
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2661
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dgboy2000[P]compress/compress.cpp
// Function: DATCompression::run_length_encode(std::vector<int, std::allocator<int>>)
vector<int> DATCompression::run_length_encode(vector<int> data) {
    int n = data.size();
    vector<int> encoded;
    encoded.reserve(n); // Heuristic; reserve enough space for the data
    
    int i=0;
    while (i < n) {
        int run_int = data[i];
        int run_count = 1;
        ++i;
        while (i < n && data[i] == run_int && run_count < RUN_MAX) {
            ++run_count;
            ++i;
        }
        for (int j=0; j<run_count && j<RUN_MIN; ++j) encoded.push_back(run_int);
        if (run_count >= RUN_MIN) encoded.push_back(run_count - RUN_MIN);
    }
    
    return encoded;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdx), %r13
movq %rdx, 0x10(%rsp)
subq (%rdx), %r13
shrq $0x2, %r13
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movslq %r13d, %rsi
callq 0x6304
testl %r13d, %r13d
jle 0x2e5c
movl %r13d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movq %rsp, %r15
movslq %eax, %rsi
movq 0x10(%rsp), %rcx
movq (%rcx), %rdx
movl (%rdx,%rsi,4), %ecx
movl %ecx, (%rsp)
leal 0x1(%rsi), %ebp
movl $0x1, %r12d
cmpl %r13d, %ebp
jge 0x2ddf
leaq (%rdx,%rsi,4), %rdx
movl %r13d, %r12d
subl %esi, %r12d
movq 0x8(%rsp), %rdi
subq %rsi, %rdi
movl $0x1, %esi
cmpl %ecx, (%rdx,%rsi,4)
jne 0x2dd8
cmpl $0x102, %esi            # imm = 0x102
ja 0x2dd8
incq %rsi
cmpq %rsi, %rdi
jne 0x2dbe
movl %r13d, %ebp
jmp 0x2ddf
addl %esi, %eax
movl %esi, %r12d
movl %eax, %ebp
cmpl $0x4, %r12d
movl $0x4, %r14d
cmovbl %r12d, %r14d
cmpl $0x1, %r14d
adcl $0x0, %r14d
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2e0e
movl (%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2e19
movq %rbx, %rdi
movq %r15, %rdx
callq 0x652a
decl %r14d
jne 0x2df5
cmpl $0x3, %r12d
jbe 0x2e51
addl $-0x4, %r12d
movl %r12d, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2e44
movl %r12d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2e51
movq %rbx, %rdi
leaq 0x4(%rsp), %rdx
callq 0x664a
movl %ebp, %eax
cmpl %r13d, %ebp
jl 0x2d88
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e72
jmp 0x2e72
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2e89
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x553e
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %r15, %rax
shlq $0x1e, %rax
movabsq $0x400000000, %rsi      # imm = 0x400000000
addq %rax, %rsi
sarq $0x20, %rsi
movq %rbx, %rdi
callq 0x63a0
shrq $0x2, %r15
movq (%rbx), %rdx
movq 0x8(%r14), %rax
movl -0x4(%rax), %eax
movl %eax, (%rdx)
leaq 0x4(%rdx), %rax
movq 0x10(%rsp), %rdi
testl %r15d, %r15d
jle 0x2f39
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %edx, %edx
movslq (%rdi,%rdx,4), %rsi
testq %rsi, %rsi
je 0x2f20
movq (%r14), %r8
movl -0x4(%r8,%rsi,4), %esi
incq %rdx
jmp 0x2f28
incq %rdx
xorl %esi, %esi
movq %rdx, %rcx
movl %esi, (%rax)
addq $0x4, %rax
cmpq %r15, %rdx
jne 0x2f0a
leaq -0x4(%rax), %rdx
jmp 0x2f39
leaq 0xffff(%rcx), %rsi
leaq 0xff(%rcx), %r8
testq %rcx, %rcx
cmovnsq %rcx, %rsi
cmovnsq %rcx, %r8
shrq $0x10, %rsi
sarq $0x8, %r8
leal 0xff(%r8), %r9d
testq %r8, %r8
cmovnsl %r8d, %r9d
movl %esi, (%rax)
andl $0xffffff00, %r9d       # imm = 0xFFFFFF00
movl %r8d, %eax
subl %r9d, %eax
movl %eax, 0x8(%rdx)
shll $0x8, %r8d
subl %r8d, %ecx
movl %ecx, 0xc(%rdx)
callq 0x21f0
movq 0x18(%rsp), %rdi
callq 0x21f0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2fb7
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq 0x10(%rsp), %rdi
callq 0x21f0
movq 0x18(%rsp), %rdi
callq 0x21f0
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dgboy2000[P]compress/compress.cpp
// Function: DATCompression::golomb_decompress(std::vector<int, std::allocator<int>>)
vector<int> DATCompression::golomb_decompress(vector<int> compressed)
{
  vector<int> decompressed;
  int temp, q = 0, r = 0, power = 1, nr = 0;
  char status = 'q';

  for(int i = 0; i < compressed.size(); i++)
  {
    temp = compressed[i];
    for(int j = 0; j < 8; j++)
    {
      if(status == 'q')
      {
        if((temp & 0x80) == 0x80)
          q++;
        else
          status = 'r', r = 0, power = 1, nr = 0;
      }
      else
      {
        if((temp & 0x80) == 0x80)
          r += power;
        nr++, power *= 2;
        if(nr == int(log(golomb_n) / log(2.0) + 1e-8))
        {
          status = 'q';
          decompressed.push_back(q * golomb_n + r);
          q = 0;
        }
      }
      temp <<= 1;
    }
  }

  return decompressed;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq %rdi, 0x10(%rsp)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rax
movq %rdx, 0x20(%rsp)
cmpq %rax, 0x8(%rdx)
je 0x406a
movl $0x1, 0x8(%rsp)
xorl %edx, %edx
movb $0x71, %sil
movl $0x0, 0x4(%rsp)
movl $0x0, 0xc(%rsp)
xorl %r12d, %r12d
movq %rdx, 0x28(%rsp)
movl (%rax,%rdx,4), %r15d
movl $0x8, %r14d
cmpb $0x71, %sil
je 0x3ffd
movb %sil, 0x3(%rsp)
movsbl %r15b, %eax
sarl $0x7, %eax
movl 0x8(%rsp), %ecx
andl %ecx, %eax
movl 0xc(%rsp), %ebp
addl %eax, %ebp
movl 0x4(%rsp), %r13d
incl %r13d
addl %ecx, %ecx
movl %ecx, 0x8(%rsp)
movq 0x30(%rsp), %rbx
xorps %xmm0, %xmm0
cvtsi2sdl (%rbx), %xmm0
callq 0x2160
divsd 0x4054(%rip), %xmm0     # 0x8008
addsd 0x4054(%rip), %xmm0     # 0x8010
cvttsd2si %xmm0, %eax
movl %r13d, 0x4(%rsp)
cmpl %eax, %r13d
movl %ebp, 0xc(%rsp)
jne 0x3ff6
imull (%rbx), %r12d
addl %ebp, %r12d
movl %r12d, 0x1c(%rsp)
movq 0x10(%rsp), %rbx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4027
movl %r12d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4034
movb 0x3(%rsp), %sil
jmp 0x403a
testb %r15b, %r15b
js 0x401f
movb $0x72, %sil
movl $0x1, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x4(%rsp)
jmp 0x403a
incl %r12d
movb $0x71, %sil
jmp 0x403a
movq %rbx, %rdi
leaq 0x1c(%rsp), %rdx
callq 0x664a
movb $0x71, %sil
xorl %r12d, %r12d
addl %r15d, %r15d
decl %r14d
jne 0x3f6b
movq 0x28(%rsp), %rdx
incq %rdx
movq 0x20(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rdx, %rcx
ja 0x3f5c
movq 0x10(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x409a
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/dgboy2000[P]compress/compress.cpp
// Function: DATCompression::run_length_decode(std::vector<int, std::allocator<int>>)
vector<int> DATCompression::run_length_decode(vector<int> encoded) {
    int n = encoded.size();
    vector<int> decoded;
    decoded.reserve(n); // Heuristic; reserve some space for the data

    vector<int>::iterator viter = encoded.begin(), data_end = encoded.end();
    while (viter != data_end) {
        int run_int = *(viter++);
        int run_count = 1;
        while (*viter == run_int && run_count < RUN_MIN && viter != data_end) {
            ++viter;
            ++run_count;
        }
        if (run_count == RUN_MIN) run_count += *(viter++);
        for (int i=0; i<run_count; ++i) decoded.push_back(run_int);
    }
    
    return decoded;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rax
subq (%rdx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
shrq $0x2, %rax
movslq %eax, %rsi
callq 0x6304
movq (%r14), %r12
movq 0x8(%r14), %r15
cmpq %r15, %r12
je 0x417b
leaq 0xc(%rsp), %r14
movl (%r12), %eax
movl %eax, 0xc(%rsp)
cmpl %eax, 0x4(%r12)
jne 0x4133
addq $0x8, %r12
movl $0x1, %ecx
leaq -0x4(%r12), %rdx
cmpq %r15, %rdx
je 0x413e
leal 0x1(%rcx), %ebp
movl (%r12), %edx
addq $0x4, %r12
cmpl %eax, %edx
jne 0x4122
cmpl $0x3, %ecx
movl %ebp, %ecx
jb 0x4102
cmpl $0x4, %ebp
jne 0x4145
cmpl $-0x4, %edx
jle 0x4172
addl $0x4, %edx
movl %edx, %ebp
jmp 0x4149
addq $0x4, %r12
movl $0x1, %ebp
jmp 0x4149
movl %ecx, %ebp
movq %rdx, %r12
jmp 0x4149
addq $-0x4, %r12
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4163
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x416e
movq %rbx, %rdi
movq %r14, %rdx
callq 0x652a
decl %ebp
jne 0x4149
cmpq %r15, %r12
jne 0x40ea
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x418d
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x41a4
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/dgboy2000[P]compress/compress.cpp
// Function: DATCompression::frame_diff_decompress(std::vector<int, std::allocator<int>>)
vector<int> DATCompression::frame_diff_decompress(vector<int> compressed)
{
  vector<int> decompressed;
  int x = compressed[0], y = compressed[1], l = compressed[2], q, r;

  decompressed.push_back(x);
  decompressed.push_back(y);
  decompressed.push_back(l);

  for(int x_ind = 0; x_ind < x; x_ind++)
    for(int y_ind = 0; y_ind < y; y_ind++)
    {
      q = compressed[3 + 2 * (x_ind * y + y_ind)];
      r = compressed[3 + 2 * (x_ind * y + y_ind) + 1];
      decompressed.push_back(q * 256 + r);
    }

  return decompressed;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rax
movl (%rax), %ecx
leaq 0x4(%rsp), %rdx
movl %ecx, (%rdx)
movl 0x4(%rax), %r15d
movl %r15d, (%rsp)
movl 0x8(%rax), %ebp
movl %ebp, 0xc(%rsp)
xorl %esi, %esi
callq 0x652a
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
cmpq %rax, %rsi
je 0x4608
movl %r15d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x461b
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x652a
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
cmpq %rax, %rsi
je 0x462c
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4639
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x652a
movl 0x4(%rsp), %ecx
testl %ecx, %ecx
jle 0x46a5
xorl %ebp, %ebp
movl (%rsp), %eax
leaq 0x8(%rsp), %r15
testl %eax, %eax
jle 0x469f
xorl %r12d, %r12d
imull %ebp, %eax
addl %r12d, %eax
addl %eax, %eax
movq (%r14), %rcx
movslq %eax, %rdx
movl 0xc(%rcx,%rdx,4), %eax
shll $0x8, %eax
addl 0x10(%rcx,%rdx,4), %eax
movl %eax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4685
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4690
movq %rbx, %rdi
movq %r15, %rdx
callq 0x664a
incl %r12d
movl (%rsp), %eax
cmpl %eax, %r12d
jl 0x4652
movl 0x4(%rsp), %ecx
incl %ebp
cmpl %ecx, %ebp
jl 0x464b
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x46b7
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x46ce
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/dgboy2000[P]compress/compress.cpp
// Function: DATCompression::compute_diffs(std::vector<int, std::allocator<int>>)
vector<int> DATCompression::compute_diffs(vector<int> data) {
    vector<int> diffs;
    
    int x = data[0];
    int y = data[1];
    int L = data[2];
    
    vector<int>::iterator viter = data.begin();
    viter++;
    viter++;
    viter++;
    
    for (int x_ind=0; x_ind < x; ++x_ind) {
        for (int y_ind=0; y_ind < y; ++y_ind) {
            int val = data[3 + L * (x_ind*y + y_ind)];
                        
            for (int L_ind=1; L_ind < L; ++L_ind) {
                int diff = data[3 + L * (x_ind*y + y_ind) + L_ind] - val;
                val = diff + val;
                diffs.push_back(diff);
            }
        }
    }
    
    return diffs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rax
movslq (%rax), %rcx
movq %rcx, 0x30(%rsp)
testq %rcx, %rcx
jle 0x4c4f
movq %rdx, %r14
movl 0x4(%rax), %ecx
movl 0x8(%rax), %eax
movslq %eax, %rdx
movq %rcx, 0x20(%rsp)
movslq %ecx, %rcx
movq %rcx, 0x28(%rsp)
movq %rdx, 0x40(%rsp)
imull %edx, %ecx
movl %ecx, 0x18(%rsp)
movq %rax, %rcx
decq %rcx
movq %rcx, 0x38(%rsp)
movl $0x3, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq %rax, 0x50(%rsp)
cmpl $0x0, 0x20(%rsp)
jle 0x4c2b
movq 0x10(%rsp), %rcx
imulq 0x28(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movl 0x8(%rsp), %ecx
movl %ecx, 0xc(%rsp)
xorl %r13d, %r13d
cmpl $0x2, %eax
jl 0x4c18
movl 0xc(%rsp), %ebp
incq %rbp
movq (%r14), %rax
movq 0x48(%rsp), %rcx
addq %r13, %rcx
imulq 0x40(%rsp), %rcx
movl 0xc(%rax,%rcx,4), %r12d
movq 0x38(%rsp), %r15
movl %r12d, %ecx
movq (%r14), %rax
movl (%rax,%rbp,4), %r12d
movl %r12d, %eax
subl %ecx, %eax
movl %eax, 0x1c(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4c03
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4c10
movq %rbx, %rdi
leaq 0x1c(%rsp), %rdx
callq 0x652a
incq %rbp
decq %r15
jne 0x4bda
incq %r13
movq 0x50(%rsp), %rax
addl %eax, 0xc(%rsp)
cmpq 0x20(%rsp), %r13
jne 0x4bb3
movq 0x10(%rsp), %rdx
incq %rdx
movl 0x8(%rsp), %ecx
addl 0x18(%rsp), %ecx
movl %ecx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
cmpq 0x30(%rsp), %rdx
jne 0x4b8d
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4c78
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/dgboy2000[P]compress/compress.cpp
// Function: DATCompression::encode_positive(std::vector<int, std::allocator<int>>)
vector<int> DATCompression::encode_positive(vector<int> nonpositive) {
    vector<int> positive;
    positive.reserve(nonpositive.size());
    
    for (vector<int>::iterator viter = nonpositive.begin(); viter != nonpositive.end(); ++viter) {
        int val = *viter;
        if (val == 0) positive.push_back(0);
        else if (val > 0) positive.push_back(2*val - 1);
        else positive.push_back(-2*val);
    }
    return positive;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
sarq $0x2, %rsi
callq 0x6304
movq (%r14), %rbp
cmpq 0x8(%r14), %rbp
je 0x4d59
leaq 0x14(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
movl (%rbp), %eax
testl %eax, %eax
je 0x4cf0
jle 0x4d0a
leal -0x1(,%rax,2), %eax
movl %eax, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4d32
movl %eax, (%rsi)
jmp 0x4d1e
movl $0x0, 0x14(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4d3f
movl $0x0, (%rsi)
jmp 0x4d1e
addl %eax, %eax
negl %eax
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4d4c
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
addq $0x4, %rbp
cmpq 0x8(%r14), %rbp
jne 0x4cce
jmp 0x4d59
movq %rbx, %rdi
movq %r12, %rdx
callq 0x664a
jmp 0x4d26
movq %rbx, %rdi
movq %r15, %rdx
callq 0x664a
jmp 0x4d26
movq %rbx, %rdi
movq %r13, %rdx
callq 0x664a
jmp 0x4d26
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d71
jmp 0x4d71
jmp 0x4d71
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4d88
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/dgboy2000[P]compress/compress.cpp
// Function: DATCompression::decode_positive(std::vector<int, std::allocator<int>>)
vector<int> DATCompression::decode_positive(vector<int> positive) {
    vector<int> nonpositive;
    nonpositive.reserve(positive.size());
    
    for (vector<int>::iterator viter = positive.begin(); viter != positive.end(); ++viter) {
        int val = *viter;
        if (val % 2 == 1) nonpositive.push_back((val+1) / 2);
        else nonpositive.push_back(-val/2);
    }
    return nonpositive;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
sarq $0x2, %rsi
callq 0x6304
movq (%r14), %r13
cmpq 0x8(%r14), %r13
je 0x4e42
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
movl (%r13), %eax
movl %eax, %ecx
andl $0x80000001, %ecx       # imm = 0x80000001
cmpl $0x1, %ecx
jne 0x4dfb
incl %eax
shrl %eax
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4e20
movl %eax, (%rsi)
jmp 0x4e16
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
negl %ecx
movl %ecx, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4e2d
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4e38
movq %rbx, %rdi
movq %r15, %rdx
callq 0x664a
jmp 0x4e38
movq %rbx, %rdi
movq %r12, %rdx
callq 0x664a
addq $0x4, %r13
cmpq 0x8(%r14), %r13
jne 0x4dd4
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4e57
jmp 0x4e57
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4e6e
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/dgboy2000[P]compress/compress.cpp
// Function: DATCompression::run_length_encode(int*, int)
int *DATCompression::run_length_encode(int *data, int n) {
    vector<int> encoded;
    int *rle;
    encoded.reserve(n); // Heuristic; reserve enough space for the data
    
    int i=0;
    while (i < n) {
        int run_int = data[i];
        int run_count = 1;
        ++i;
        while (i < n && data[i] == run_int && run_count < RUN_MAX) {
            ++run_count;
            ++i;
        }
        for (int j=0; j<run_count && j<RUN_MIN; ++j) encoded.push_back(run_int);
        if (run_count >= RUN_MIN) encoded.push_back(run_count - RUN_MIN);
    }
    
    rle = (int *) calloc(encoded.size()+1, sizeof(encoded));
    rle[0] = n;
    copy(encoded.begin(), encoded.end(), rle+1);
    
    return rle;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r15d
movq %rsi, 0x38(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movslq %edx, %rsi
movq %rsi, 0x40(%rsp)
callq 0x6304
testl %r15d, %r15d
jle 0x4f97
xorl %eax, %eax
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
movslq %eax, %rsi
movq 0x38(%rsp), %rcx
movl (%rcx,%rsi,4), %ecx
movl %ecx, 0xc(%rsp)
leal 0x1(%rsi), %ebp
movl $0x1, %ebx
cmpl %r15d, %ebp
jge 0x4f18
movq 0x38(%rsp), %rdx
leaq (%rdx,%rsi,4), %rdx
movl %r15d, %ebx
subl %esi, %ebx
movq 0x40(%rsp), %rdi
subq %rsi, %rdi
movl $0x1, %esi
cmpl %ecx, (%rdx,%rsi,4)
jne 0x4f12
cmpl $0x102, %esi            # imm = 0x102
ja 0x4f12
incq %rsi
cmpq %rsi, %rdi
jne 0x4ef8
movl %r15d, %ebp
jmp 0x4f18
addl %esi, %eax
movl %esi, %ebx
movl %eax, %ebp
cmpl $0x4, %ebx
movl $0x4, %r14d
cmovbl %ebx, %r14d
cmpl $0x1, %r14d
adcl $0x0, %r14d
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x4f4a
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x4f55
movq %r12, %rdi
movq %r13, %rdx
callq 0x652a
decl %r14d
jne 0x4f2d
cmpl $0x3, %ebx
jbe 0x4f8c
addl $-0x4, %ebx
movl %ebx, 0x34(%rsp)
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x4f7f
movl %ebx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x4f8c
movq %r12, %rdi
leaq 0x34(%rsp), %rdx
callq 0x664a
movl %ebp, %eax
cmpl %r15d, %ebp
jl 0x4ec1
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r12
movq %r12, %rdi
subq %r14, %rdi
sarq $0x2, %rdi
incq %rdi
movl $0x18, %esi
callq 0x2110
movq %rax, %rbx
movl %r15d, (%rax)
subq %r14, %r12
je 0x4fd2
leaq 0x4(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2170
testq %r14, %r14
je 0x4fe7
movq 0x20(%rsp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x21b0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4ffd
jmp 0x4ffd
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5017
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dgboy2000[P]compress/compress.cpp
// Function: DATCompression::run_length_decode(int*)
int *DATCompression::run_length_decode(int *encoded) {
    int n = encoded[0];
    int *decoded = (int *) calloc(n, sizeof(int));

    int cur_ind = 1;
    int total_count = 0;
    while (total_count < n) {
        int run_int = encoded[cur_ind++];
        int run_count = 1;
        while (encoded[cur_ind] == run_int && run_count < RUN_MIN) {
            ++cur_ind;
            ++run_count;
        }
        if (run_count == RUN_MIN) run_count += encoded[cur_ind++];
        for (int i=0; i<run_count; ++i) decoded[total_count++] = run_int;
    }
    
    return decoded;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq (%rsi), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x2110
testq %r14, %r14
jle 0x50a9
leaq 0x4(%rbx), %rcx
xorl %edx, %edx
movl $0x1, %edi
movslq %edi, %r8
movl (%rbx,%r8,4), %esi
leaq (%rcx,%r8,4), %r11
xorl %r10d, %r10d
xorl %edi, %edi
movl (%r11,%r10,4), %r9d
incq %r10
decq %rdi
cmpl %esi, %r9d
jne 0x506c
cmpl $0x4, %r10d
jb 0x5057
subq %rdi, %r8
leaq 0x1(%r8), %rdi
addl $0x4, %r9d
cmpl $0x4, %r10d
cmovneq %r8, %rdi
cmovnel %r10d, %r9d
testl %r9d, %r9d
jle 0x50a4
movslq %edx, %r8
leaq (%rax,%r8,4), %r8
movl %r9d, %r9d
xorl %r10d, %r10d
movl %esi, (%r8,%r10,4)
incq %r10
cmpl %r10d, %r9d
jne 0x5095
addl %r10d, %edx
cmpl %r14d, %edx
jl 0x5047
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dgboy2000[P]compress/compress.cpp
// Function: DATCompression::burrows_wheeler_encode(int*, int)
int *DATCompression::burrows_wheeler_encode(int *data, int n) {
    SuffixArray sa(data, n);
    
    int *bwt = (int *) calloc(n+4, sizeof(int));
    long int dollar_ind;
    bwt[0] = data[n-1];
    
    for (int i=0; i<n; ++i) {
        if (sa[i] == 0) {
            bwt[i+1] = INT_MIN;
            dollar_ind = i + 1;
        }
        else bwt[i+1] = data[sa[i] - 1];
    }
    
    bwt[n+1] = dollar_ind / (256*256);
    bwt[n+2] = (dollar_ind / 256) % 256;
    bwt[n+3] = dollar_ind % 256;
    
    return bwt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r15d
movq %rsi, %r14
leaq 0x8(%rsp), %r12
movl %edx, (%r12)
leal 0x3(%r15), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x2110
movq %rax, 0x10(%r12)
movslq %r15d, %r13
leaq (,%r13,4), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2170
movq %r12, %rdi
callq 0x559e
leal 0x4(%r13), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x2110
movq %rax, %rbx
movl -0x4(%r14,%r13,4), %eax
movl %eax, (%rbx)
movq 0x8(%r12), %rdi
testl %r13d, %r13d
jle 0x5158
movl %r15d, %ecx
xorl %edx, %edx
movslq (%rdi,%rdx,4), %rsi
testq %rsi, %rsi
je 0x5143
movl -0x4(%r14,%rsi,4), %esi
movl %esi, 0x4(%rbx,%rdx,4)
incq %rdx
jmp 0x5151
movl $0x80000000, 0x4(%rbx,%rdx,4) # imm = 0x80000000
incq %rdx
movq %rdx, %rax
cmpq %rcx, %rdx
jne 0x512c
jmp 0x5158
leaq 0xffff(%rax), %rcx
leaq 0xff(%rax), %rdx
testq %rax, %rax
cmovnsq %rax, %rcx
cmovnsq %rax, %rdx
shrq $0x10, %rcx
sarq $0x8, %rdx
leal 0xff(%rdx), %esi
testq %rdx, %rdx
cmovnsl %edx, %esi
movl %ecx, 0x4(%rbx,%r13,4)
andl $0xffffff00, %esi       # imm = 0xFFFFFF00
movl %edx, %ecx
subl %esi, %ecx
movl %ecx, 0x8(%rbx,%r13,4)
shll $0x8, %edx
subl %edx, %eax
movl %eax, 0xc(%rbx,%r13,4)
callq 0x21f0
movq 0x18(%rsp), %rdi
callq 0x21f0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq