LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/_dict.c
// Function: SH_dict_bucket__add
void
SH_dict_bucket__add(SH_dict_bucket* obj, SH_dict_pair* pair, int* err) {
	__cascade(err,);
	while (obj->num >= SH_dict_bucket_size) {
		if ((SH_dict_bucket*)0 == obj->next) {
			obj->next = SH_dict_bucket__init(err);
			if (err) return;
		}
		obj = obj->next;
	}
	obj->pairs[obj->num] = pair;
	obj->num ++;

	__clear(err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x1327
cmpl $0x0, (%rbx)
jne 0x1372
movq (%r15), %rcx
cmpq $0x4, %rcx
jb 0x1358
movq 0x28(%r15), %rax
testq %rax, %rax
jne 0x134a
movq %rbx, %rdi
callq 0x10e0
movq %rax, 0x28(%r15)
testq %rbx, %rbx
jne 0x1372
movq (%rax), %rcx
movq %rax, %r15
cmpq $0x3, %rcx
ja 0x1330
jmp 0x135b
movq %r15, %rax
leaq 0x1(%rcx), %rdx
movq %r14, 0x8(%rax,%rcx,8)
movq %rdx, (%rax)
testq %rbx, %rbx
je 0x1372
movl $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/_dict.c
// Function: SH_dict__init
SH_dict*
SH_dict__init(int* err) {
	SH_dict* obj;

	__cascade(err, (SH_dict*)0);

	obj = (SH_dict*)calloc(sizeof(SH_dict), 1);
	if ((SH_dict*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_dict*)0;
	}

	__clear(err);
	return obj;
}

// Assembly:
testq %rdi, %rdi
je 0x138a
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x1399
xorl %eax, %eax
jmp 0x13b3
movl $0x808, %edi            # imm = 0x808
movl $0x1, %esi
jmp 0x1080
movl $0x808, %edi            # imm = 0x808
movl $0x1, %esi
callq 0x1080
testq %rax, %rax
je 0x13b5
movl $0x0, (%rbx)
popq %rbx
retq
movl $0x80000001, (%rbx)     # imm = 0x80000001
jmp 0x1386
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/_dict.c
// Function: SH_dict__destroy
void
SH_dict__destroy(SH_dict* obj, sh_bool_t recursive, int* err) {
	__cascade(err,);
	if ((SH_dict_bucket*)0 != obj->_list) {
		SH_dict_bucket__destroy(obj->_list, recursive, err);
	}
	free(obj);
	__clear(err);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x13d1
cmpl $0x0, (%rbx)
jne 0x13fc
movq 0x800(%r14), %rdi
testq %rdi, %rdi
je 0x13e9
movzbl %sil, %esi
movq %rbx, %rdx
callq 0x10c0
movq %r14, %rdi
callq 0x1030
testq %rbx, %rbx
je 0x13fc
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/_dict.c
// Function: SH_dict__get
SH_Item*
SH_dict__get(SH_dict* obj, SH_Key* key, int* err) {
	size_t i;
	uint8_t hash;
	SH_dict_bucket* bucket;
	SH_dict_pair* pair;

	hash = SH_Key__hash(key, err);
	bucket = obj->_hash[hash];

	__cascade(err, (SH_Item*)0);

	while ((SH_dict_bucket*)0 != bucket) {
		for (i = 0; /*i < SH_dict_bucket_size &&*/ i < bucket->num; i++) {
			pair = bucket->pairs[i];
			if (SH_Key__equal(key, pair->key, 0)) { /*FIXME: err?*/
				__clear(err);
				return pair->value;
			}
		}
		bucket = bucket->next;
	}

	/* not found, but no error */
	__clear(err);
	return (SH_Item*)0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x10b0
movzbl %al, %eax
movq (%r15,%rax,8), %r15
testq %rbx, %rbx
je 0x1460
cmpl $0x0, (%rbx)
jne 0x1470
jmp 0x1460
cmpq $0x0, (%r15)
je 0x145c
xorl %r12d, %r12d
movq 0x8(%r15,%r12,8), %r13
movq (%r13), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1050
testb %al, %al
jne 0x1474
incq %r12
cmpq (%r15), %r12
jb 0x143d
movq 0x28(%r15), %r15
testq %r15, %r15
jne 0x1434
testq %rbx, %rbx
je 0x1470
movl $0x0, (%rbx)
xorl %eax, %eax
jmp 0x1483
testq %rbx, %rbx
je 0x147f
movl $0x0, (%rbx)
movq 0x8(%r13), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/_dict.c
// Function: SH_dict__count
size_t
SH_dict__count(SH_dict* obj, int* err) {
	SH_dict_bucket* bucket;
	size_t n = 0;

	__cascade(err, (size_t)0);

	bucket = obj->_list;
	while ((SH_dict_bucket*)0 != bucket) {
		n += bucket->num;
		bucket = bucket->next;
	}

	__clear(err);
	return n;
}

// Assembly:
testq %rsi, %rsi
je 0x149a
cmpl $0x0, (%rsi)
je 0x149a
xorl %eax, %eax
retq
movq 0x800(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x14b1
addq (%rcx), %rax
movq 0x28(%rcx), %rcx
jmp 0x14a3
testq %rsi, %rsi
je 0x14bc
movl $0x0, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/_dict.c
// Function: SH_dict__add
void
SH_dict__add(SH_dict* obj, SH_Key* key, SH_Item* value, int* err) {
	SH_dict_pair* pair;
	uint8_t hash;

	__cascade(err,);

	pair = SH_dict_pair__init(key, value, err);
	__cascade(err,);

	/* add it to the _hash array */

	hash = SH_Key__hash(pair->key, err);
	if ((SH_dict_bucket*)0 == obj->_hash[hash]) {
		obj->_hash[hash] = SH_dict_bucket__init(err);
		__cascade(err,);
	}
	SH_dict_bucket__add(obj->_hash[hash], pair, err);
	__cascade(err,);

	/* add it to the _list list */

	if ((SH_dict_bucket*)0 == obj->_list) {
		obj->_list = SH_dict_bucket__init(err);
		__cascade(err,);
	}
	SH_dict_bucket__add(obj->_list, pair, err);
	__cascade(err,); /* FIXME are we left in a broken state? */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
testq %rcx, %rcx
je 0x14f2
cmpl $0x0, (%rbx)
jne 0x15a2
movq %rsi, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x10d0
cmpl $0x0, (%rbx)
jne 0x15a2
jmp 0x14ff
movq %rsi, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x10d0
movq %rax, %r15
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x10b0
movzbl %al, %r12d
movq (%r14,%r12,8), %rdi
testq %rdi, %rdi
je 0x1531
movq %r15, %rsi
movq %rbx, %rdx
callq 0x10a0
testq %rbx, %rbx
je 0x1564
cmpl $0x0, (%rbx)
jne 0x15a2
jmp 0x1564
movq %rbx, %rdi
callq 0x10e0
movq %rax, (%r14,%r12,8)
testq %rbx, %rbx
je 0x1557
cmpl $0x0, (%rbx)
jne 0x15a2
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x10a0
jmp 0x152a
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x10a0
movq 0x800(%r14), %rdi
testq %rdi, %rdi
je 0x1586
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10a0
movq %rbx, %rdi
callq 0x10e0
movq %rax, %rdi
movq %rax, 0x800(%r14)
testq %rbx, %rbx
je 0x15ae
cmpl $0x0, (%rbx)
je 0x1570
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rsi
xorl %edx, %edx
jmp 0x1576
// File: /workspace/github_c_makefile_star2_O3/mloar[P]charset/toucs.c
// Function: charset_to_unicode
int charset_to_unicode(const char **input, int *inlen,
		       wchar_t *output, int outlen,
		       int charset, charset_state *state,
		       const wchar_t *errstr, int errlen)
{
    charset_spec const *spec = charset_find_spec(charset);
    charset_state localstate = CHARSET_INIT_STATE;
    struct unicode_emit_param param;

    param.output = output;
    param.outlen = outlen;
    param.errstr = errstr;
    param.errlen = errlen;
    param.writtenlen = 0;
    param.stopped = 0;

    if (state)
	localstate = *state;	       /* structure copy */

    while (*inlen > 0) {
	int lenbefore = param.writtenlen;
	spec->read(spec, (unsigned char)**input, &localstate,
		   unicode_emit, &param);
	if (param.stopped) {
	    /*
	     * The emit function has _tried_ to output some
	     * characters, but ran up against the end of the
	     * buffer. Leave immediately, and return what happened
	     * _before_ attempting to process this character.
	     */
	    return lenbefore;
	}
	if (state)
	    *state = localstate;   /* structure copy */
	(*input)++;
	(*inlen)--;
    }

    return param.writtenlen;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movl %r8d, %edi
callq 0x6794
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq %r13, (%rsp)
movl %ebp, 0x8(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x78(%rsp), %eax
movl %eax, 0x18(%rsp)
xorl %ebp, %ebp
movl %ebp, 0xc(%rsp)
movl %ebp, 0x1c(%rsp)
testq %rbx, %rbx
je 0x6840
movups (%rbx), %xmm0
movaps %xmm0, 0x20(%rsp)
cmpl $0x0, (%r14)
jle 0x6899
movq (%r15), %rax
movq %rsp, %r13
movl 0xc(%rsp), %ebp
movzbl (%rax), %esi
movq %r12, %rdi
leaq 0x20(%rsp), %rdx
leaq 0x48(%rip), %rcx        # 0x68aa
movq %r13, %r8
callq *0x8(%r12)
cmpl $0x0, 0x1c(%rsp)
jne 0x6899
testq %rbx, %rbx
je 0x687e
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rbx)
movq (%r15), %rax
incq %rax
movq %rax, (%r15)
movl (%r14), %ecx
leal -0x1(%rcx), %edx
movl %edx, (%r14)
cmpl $0x1, %ecx
jg 0x684c
movl 0xc(%rsp), %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mloar[P]charset/toucs.c
// Function: unicode_emit
static void unicode_emit(void *ctx, long int output)
{
    struct unicode_emit_param *param = (struct unicode_emit_param *)ctx;
    wchar_t outval;
    wchar_t const *p;
    int outlen;

    if (output == ERROR) {
	if (param->errstr) {
	    p = param->errstr;
	    outlen = param->errlen;
	} else {
	    outval = 0xFFFD;	       /* U+FFFD REPLACEMENT CHARACTER */
	    p = &outval;
	    outlen = 1;
	}
    } else {
	outval = output;
	p = &outval;
	outlen = 1;
    }

    if (param->outlen < 0 || param->outlen >= outlen) {
	while (outlen > 0) {
	    if (param->output)
		*param->output++ = *p++;
	    if (param->outlen > 0)
		param->outlen--;
	    outlen--;
	    param->writtenlen++;
	}
    } else {
	param->stopped = 1;
    }
}

// Assembly:
cmpq $0xffff, %rsi           # imm = 0xFFFF
jne 0x68c1
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x68ca
movl 0x18(%rdi), %ecx
jmp 0x68da
leaq -0x4(%rsp), %rax
movl %esi, (%rax)
jmp 0x68d5
leaq -0x4(%rsp), %rax
movl $0xfffd, (%rax)         # imm = 0xFFFD
movl $0x1, %ecx
movl 0x8(%rdi), %edx
testl %edx, %edx
setns %sil
cmpl %ecx, %edx
setl %r8b
testb %r8b, %sil
je 0x68f6
movl $0x1, 0x1c(%rdi)
retq
testl %ecx, %ecx
jle 0x6930
movq (%rdi), %rsi
incl %ecx
testq %rsi, %rsi
je 0x691b
movl (%rax), %edx
addq $0x4, %rax
leaq 0x4(%rsi), %r8
movq %r8, (%rdi)
movl %edx, (%rsi)
movl 0x8(%rdi), %edx
movq %r8, %rsi
jmp 0x691d
xorl %esi, %esi
testl %edx, %edx
jle 0x6926
decl %edx
movl %edx, 0x8(%rdi)
incl 0xc(%rdi)
decl %ecx
cmpl $0x1, %ecx
jg 0x68ff
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/recovery.c
// Function: main
int main(void)
{
	run("Control", scen_control);
	run("Instant fail", scen_instant_fail);

	run("Fail after checkpoint", scen_after_check);
	run("Fail mid-checkpoint", scen_mid_check);
	run("Fail on meta", scen_meta_check);

	run("Cascade fail after checkpoint", scen_after_cascade);
	run("Cascade fail mid-checkpoint", scen_mid_cascade);

	run("Metadata dump failure", scen_meta_fail);

	run("Bad day", scen_bad_day);

	return 0;
}

// Assembly:
pushq %rax
leaq 0x1eb4(%rip), %rdi      # 0x4004
leaq 0x165(%rip), %rsi       # 0x22bc
callq 0x21f8
leaq 0x1ea9(%rip), %rdi      # 0x400c
leaq 0x153(%rip), %rsi       # 0x22bd
callq 0x21f8
leaq 0x1ea3(%rip), %rdi      # 0x4019
leaq 0x147(%rip), %rsi       # 0x22c4
callq 0x21f8
leaq 0x1ea6(%rip), %rdi      # 0x402f
leaq 0x140(%rip), %rsi       # 0x22d0
callq 0x21f8
leaq 0x1ea7(%rip), %rdi      # 0x4043
leaq 0x139(%rip), %rsi       # 0x22dc
callq 0x21f8
leaq 0x1ea1(%rip), %rdi      # 0x4050
leaq 0x132(%rip), %rsi       # 0x22e8
callq 0x21f8
leaq 0x1eac(%rip), %rdi      # 0x406e
leaq 0x14b(%rip), %rsi       # 0x2314
callq 0x21f8
leaq 0x1eb5(%rip), %rdi      # 0x408a
leaq 0x155(%rip), %rsi       # 0x2331
callq 0x21f8
leaq 0x1eb8(%rip), %rdi      # 0x40a0
leaq 0x15a(%rip), %rsi       # 0x2349
callq 0x21f8
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/recovery.c
// Function: run
static void run(const char *name, void (*scen)(void))
{
	uint8_t page_buf[1 << sim_nand.log2_page_size];
	struct dhara_journal journal;

	printf("========================================"
	       "================================\n"
	       "%s\n"
	       "========================================"
	       "================================\n\n", name);

	sim_reset();
	dhara_journal_init(&journal, &sim_nand, page_buf);

	/* All tests are tuned for this value */
	assert(journal.log2_ppc == 2);

	scen();

	jt_enqueue_sequence(&journal, 0, 30);
	jt_dequeue_sequence(&journal, 0, 30);

	sim_dump();
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq 0x1f92(%rip), %r14      # 0x41a0
movb (%r14), %cl
movl $0x1, %eax
shlq %cl, %rax
movq %rsi, %rbx
movq %rdi, %rsi
addq $0xf, %rax
andq $-0x10, %rax
movq %rsp, %r15
subq %rax, %r15
movq %r15, %rsp
leaq 0x1e71(%rip), %rdi      # 0x40a8
xorl %eax, %eax
callq 0x1070
callq 0x2370
leaq -0x58(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x12ec
cmpb $0x2, 0x10(%r12)
jne 0x229d
callq *%rbx
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1e, %edx
callq 0x2bd8
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1e, %edx
callq 0x2e80
callq 0x2816
movl $0xa, %edi
callq 0x1030
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e9b(%rip), %rdi      # 0x413f
leaq 0x1eaa(%rip), %rsi      # 0x4155
leaq 0x1eb4(%rip), %rcx      # 0x4166
movl $0x25, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O3/ethinethin[P]Secret/main.c
// Function: main
void splash_screen(void)
{
	printf("\n--------------------------------------------------------------------------------\n");
	printf("Welcome to %s (game engine %s)\n",TITLE,ENGINE);
	printf("--------------------------------------------------------------------------------\n");
	printf("What lies in the mysterious forest on the edge of a small village? Myths and\n");
	printf("legends have been told for centuries, but no-one has yet figured it out. Will\n");
	printf("you be the one to finally solve this riddle? Good luck!\n");
	printf("--------------------------------------------------------------------------------\n");
	printf("To learn how to play, type: help\n");
	printf("--------------------------------------------------------------------------------\n");

}

// Assembly:
pushq %rbx
leaq 0x3c92(%rip), %rdi      # 0x7046
callq 0x3090
leaq 0x3c44(%rip), %rdi      # 0x7004
leaq 0x3c5d(%rip), %rsi      # 0x7024
leaq 0x3c6b(%rip), %rdx      # 0x7039
xorl %eax, %eax
callq 0x30f0
leaq 0x3c6b(%rip), %rbx      # 0x7047
movq %rbx, %rdi
callq 0x3090
leaq 0x3cad(%rip), %rdi      # 0x7098
callq 0x3090
leaq 0x3cee(%rip), %rdi      # 0x70e5
callq 0x3090
leaq 0x3d30(%rip), %rdi      # 0x7133
callq 0x3090
movq %rbx, %rdi
callq 0x3090
leaq 0x3d54(%rip), %rdi      # 0x716b
callq 0x3090
movq %rbx, %rdi
callq 0x3090
callq 0x3430
xorl %eax, %eax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/ethinethin[P]Secret/input.c
// Function: completion
void completion(const char *buf, linenoiseCompletions *lc) {
	if (buf[0] == 'w') {
		linenoiseAddCompletion(lc,"walk ");
		linenoiseAddCompletion(lc,"west");
	} else if (buf[0] == 'g') {
		linenoiseAddCompletion(lc,"go ");
		linenoiseAddCompletion(lc,"get ");
	} else if (buf[0] == 'm') {
		linenoiseAddCompletion(lc,"move ");
	} else if (buf[0] == 'n') {
		linenoiseAddCompletion(lc,"north");
	} else if (buf[0] == 's') {
		linenoiseAddCompletion(lc,"south");
		linenoiseAddCompletion(lc,"search");
	} else if (buf[0] == 'l') {
		linenoiseAddCompletion(lc,"look");
	} else if (buf[0] == 't') {
		linenoiseAddCompletion(lc,"take ");
	} else if (buf[0] == 'd') {
		linenoiseAddCompletion(lc,"drop ");
	} else if (buf[0] == 'i') {
		linenoiseAddCompletion(lc,"inventory");
	} else if (buf[0] == 'u') {
		linenoiseAddCompletion(lc,"use ");
	} else if (buf[0] == 'q') {
		linenoiseAddCompletion(lc,"quit");
	} else if (buf[0] == 'h') {
		linenoiseAddCompletion(lc,"help");
	} else if (buf[0] == 'e') {
		linenoiseAddCompletion(lc,"exit");
		linenoiseAddCompletion(lc,"east");
	} else if (buf[0] == 'f') {
		linenoiseAddCompletion(lc,"find");
	}
}

// Assembly:
pushq %rbx
movzbl (%rdi), %eax
addl $-0x64, %eax
cmpl $0x13, %eax
ja 0x3c92
movq %rsi, %rbx
leaq 0x35ca(%rip), %rcx      # 0x718c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x36b5(%rip), %rsi      # 0x7287
jmp 0x3c89
leaq 0x368e(%rip), %rsi      # 0x726c
movq %rbx, %rdi
callq 0x3cc9
leaq 0x3620(%rip), %rsi      # 0x720d
jmp 0x3c89
leaq 0x51eb(%rip), %rsi      # 0x8de4
movq %rbx, %rdi
callq 0x3cc9
leaq 0x3618(%rip), %rsi      # 0x7220
jmp 0x3c89
leaq 0x3576(%rip), %rsi      # 0x7187
jmp 0x3c89
leaq 0x3673(%rip), %rsi      # 0x728d
jmp 0x3c89
leaq 0x3609(%rip), %rsi      # 0x722c
jmp 0x3c89
leaq 0x3655(%rip), %rsi      # 0x7281
jmp 0x3c89
leaq 0x363d(%rip), %rsi      # 0x7272
movq %rbx, %rdi
callq 0x3cc9
leaq 0x3632(%rip), %rsi      # 0x7276
jmp 0x3c89
leaq 0x35da(%rip), %rsi      # 0x7227
jmp 0x3c89
leaq 0x3598(%rip), %rsi      # 0x71ee
movq %rbx, %rdi
callq 0x3cc9
leaq 0x35a3(%rip), %rsi      # 0x7208
jmp 0x3c89
leaq 0x3585(%rip), %rsi      # 0x71f3
jmp 0x3c89
leaq 0x3604(%rip), %rsi      # 0x727b
jmp 0x3c89
leaq 0x3569(%rip), %rsi      # 0x71e9
jmp 0x3c89
leaq 0x3579(%rip), %rsi      # 0x7202
movq %rbx, %rdi
popq %rbx
jmp 0x3cc9
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ethinethin[P]Secret/rooms.c
// Function: move
extern void move(char *direction)
{
	int dir;

	putchar('\n');

	/* figure out direction */
	if (direction == NULL) {
		printf("Walk where?\n");
		return;
	} else if (strcmp(direction,"north") == 0) {
		dir = 0;
	} else if (strcmp(direction,"east") == 0) {
		dir = 1;
	} else if (strcmp(direction,"south") == 0) {
		dir = 2;
	} else if (strcmp(direction,"west") == 0) {
		dir = 3;
	} else {
		printf("Walk where?\n");
		return;
	}

	/* move */
	if (locations[current_room].walk_to[dir] != -1) {
		printf("%s\n",locations[current_room].walk_desc[dir]);
		current_room = locations[current_room].walk_to[dir];
		room_name();
		look_room();
	} else {
		printf("You cannot walk %s.\n",direction);
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xa, %edi
callq 0x3050
testq %rbx, %rbx
je 0x570e
leaq 0x1b39(%rip), %rsi      # 0x7202
movq %rbx, %rdi
callq 0x3180
testl %eax, %eax
je 0x571f
leaq 0x1b2c(%rip), %rsi      # 0x7208
movq %rbx, %rdi
callq 0x3180
testl %eax, %eax
je 0x5724
leaq 0x36f5(%rip), %rsi      # 0x8de4
movq %rbx, %rdi
callq 0x3180
testl %eax, %eax
je 0x572c
leaq 0x1b0b(%rip), %rsi      # 0x720d
movq %rbx, %rdi
callq 0x3180
testl %eax, %eax
je 0x5734
leaq 0x43fc(%rip), %rdi      # 0x9b11
popq %rbx
popq %r14
popq %r15
jmp 0x3090
xorl %r14d, %r14d
jmp 0x573a
movl $0x1, %r14d
jmp 0x573a
movl $0x2, %r14d
jmp 0x573a
movl $0x3, %r14d
movslq 0xa4eb(%rip), %rax      # 0xfc2c
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x8a30(%rip), %r15      # 0xe180
addq %r15, %rax
cmpl $-0x1, 0x18(%rax,%r14,4)
je 0x57a7
movq 0x28(%rax,%r14,8), %rdi
callq 0x3090
movslq 0xa4c0(%rip), %rax      # 0xfc2c
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %r15, %rax
movslq 0x18(%rax,%r14,4), %rax
movl %eax, 0xa4aa(%rip)      # 0xfc2c
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
movq 0x8(%rax,%r15), %rsi
leaq 0x21ba(%rip), %rdi      # 0x7950
xorl %eax, %eax
callq 0x30f0
popq %rbx
popq %r14
popq %r15
jmp 0x55e8
leaq 0x21a7(%rip), %rdi      # 0x7955
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x30f0
// File: /workspace/github_c_makefile_star2_O3/ethinethin[P]Secret/items.c
// Function: room_items
extern void room_items(int room_id)
{
	int i;
	for(i = 0; items[i].item_id != -1; i++) {
		if (items[i].location == room_id && items[i].hidden == NO)
			printf("%s\n",items[i].item_desc_floor);
	}
}

// Assembly:
cmpl $-0x1, 0x9401(%rip)     # 0xec20
je 0x5855
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x942a(%rip), %r14      # 0xec58
cmpl %ebx, -0x8(%r14)
jne 0x5844
cmpl $0x0, -0x10(%r14)
jne 0x5844
movq -0x20(%r14), %rdi
callq 0x3090
cmpl $-0x1, (%r14)
leaq 0x38(%r14), %r14
jne 0x582e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ethinethin[P]Secret/items.c
// Function: search
extern void search(int room_id)
{
	int i;
	int count;

	putchar('\n');

	if (search_desc())
		printf("You carefully search the area. ");

	for (count = 0, i = 0; items[i].item_id != -1; i++) {
		if (items[i].location == room_id && items[i].hidden == YES) {
			if (count > 0)
				printf("\nYou also found the ");
			else
				printf("You found the ");
			count++;
			if (items[i].item_adj != NULL)
				printf("%s ",items[i].item_adj);
			printf("%s! ",items[i].item_name);
			items[i].hidden = NO;
			items[i].location = -1;
			inventory[i] = 1;
		}
	}
	if (count == 0)
		printf("You didn't find anything.\n");
	else
		putchar('\n');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0xa, %edi
callq 0x3050
callq 0x57bd
testl %eax, %eax
je 0x5884
leaq 0x4fc1(%rip), %rdi      # 0xa83e
xorl %eax, %eax
callq 0x30f0
cmpl $-0x1, 0x9395(%rip)     # 0xec20
je 0x5938
leaq 0xa398(%rip), %r12      # 0xfc30
leaq 0x93b9(%rip), %rbp      # 0xec58
leaq 0x4fcd(%rip), %r15      # 0xa873
leaq 0x4fd5(%rip), %r14      # 0xa882
xorl %r13d, %r13d
cmpl %ebx, -0x8(%rbp)
jne 0x590e
cmpl $0x1, -0x10(%rbp)
jne 0x590e
testl %r13d, %r13d
movq %r15, %rdi
leaq 0x4f96(%rip), %rax      # 0xa85e
cmovgq %rax, %rdi
xorl %eax, %eax
callq 0x30f0
movq -0x28(%rbp), %rsi
testq %rsi, %rsi
je 0x58ea
leaq 0x2087(%rip), %rdi      # 0x796a
xorl %eax, %eax
callq 0x30f0
incl %r13d
movq -0x30(%rbp), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x30f0
movl $0x0, -0x10(%rbp)
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movb $0x1, (%r12)
incq %r12
cmpl $-0x1, (%rbp)
leaq 0x38(%rbp), %rbp
jne 0x58b0
testl %r13d, %r13d
je 0x5938
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3050
leaq 0x4fe9(%rip), %rdi      # 0xa928
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3090
// File: /workspace/github_c_makefile_star2_O3/ethinethin[P]Secret/items.c
// Function: list_inv
extern void list_inv(void)
{
	int i;
	int count;

	printf("\nInventory:\n");
	for (count = 0, i = 0; items[i].item_id != -1; i++) {
		if (inventory[i] == YES) {
			count++;
			putchar('\t');
			if (items[i].item_adj != NULL)
				printf("%s ",items[i].item_adj);
			printf("%s\n",items[i].item_name);
		}
	}
	if (count == 0)
		printf("\tnothing.\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4fe2(%rip), %rdi      # 0xa942
callq 0x3090
cmpl $-0x1, 0x92b4(%rip)     # 0xec20
je 0x59cf
leaq 0xa2bb(%rip), %r14      # 0xfc30
leaq 0x92ac(%rip), %r15      # 0xec28
leaq 0x1fe7(%rip), %rbx      # 0x796a
xorl %ebp, %ebp
cmpb $0x1, (%r14)
jne 0x59b2
movl $0x9, %edi
callq 0x3050
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x59a8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30f0
incl %ebp
movq (%r15), %rdi
callq 0x3090
incq %r14
cmpl $-0x1, 0x30(%r15)
leaq 0x38(%r15), %r15
jne 0x5985
testl %ebp, %ebp
je 0x59cf
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f78(%rip), %rdi      # 0xa94e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3090
// File: /workspace/github_c_makefile_star2_O3/ethinethin[P]Secret/items.c
// Function: take_item
extern void take_item(int room_id, char *word1, char *word2)
{
	char *adj;
	char *name;
	int item_num;

	putchar('\n');

	if (word1 == NULL) {
		printf("Take what?\n");
		return;
	}
	
	/* assign an adjective if possible */
	assign_name(&word1, &word2, &adj, &name);
		
	/* find out if given name is ambiguous */
	item_num = in_room(room_id, adj, name);
	
	/* if none were found, the item is not present */
	/* if only one was found, it's not ambiguous */
	if (item_num == -1) {
		printf("There is no ");
		if (adj != NULL) printf("%s ",adj);
		printf("%s here.\n",name);
		return;
	} else if (item_num == -2) {
		printf("Which %s do you want to take?\n",name);
		return;
	}

	/* take item if possible */
	if (items[item_num].takeable == YES) {
		items[item_num].location = -1;
		inventory[item_num] = 1;
		printf("You took the ");
		if (items[item_num].item_adj != NULL)
			printf("%s ",items[item_num].item_adj);
		printf("%s.\n",name);
	} else {
		printf("You cannot take the %s!\n",name);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebp
movl $0xa, %edi
callq 0x3050
testq %r14, %r14
je 0x5a55
testq %r15, %r15
movq %r14, %rsi
cmoveq %r15, %rsi
movq %r15, %rbx
cmoveq %r14, %rbx
movl %ebp, %edi
movq %rbx, %rdx
callq 0x5ae8
cmpl $-0x2, %eax
je 0x5a6b
cmpl $-0x1, %eax
jne 0x5a74
leaq 0x4e58(%rip), %rdi      # 0xa887
xorl %eax, %eax
callq 0x30f0
testq %r15, %r15
je 0x5a4c
leaq 0x1f28(%rip), %rdi      # 0x796a
movq %r14, %rsi
xorl %eax, %eax
callq 0x30f0
leaq 0x4f49(%rip), %rdi      # 0xa99c
jmp 0x5ad4
leaq 0x4efc(%rip), %rdi      # 0xa958
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3090
leaq 0x4e22(%rip), %rdi      # 0xa894
jmp 0x5ad4
cltq
imulq $0x38, %rax, %rcx
leaq 0x919f(%rip), %r14      # 0xec20
cmpl $0x1, 0x2c(%rcx,%r14)
jne 0x5acd
addq %rcx, %r14
movl $0xffffffff, 0x30(%r14) # imm = 0xFFFFFFFF
leaq 0xa195(%rip), %rcx      # 0xfc30
movb $0x1, (%rax,%rcx)
leaq 0x4e0d(%rip), %rdi      # 0xa8b3
xorl %eax, %eax
callq 0x30f0
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x5ac4
leaq 0x1ead(%rip), %rdi      # 0x796a
xorl %eax, %eax
callq 0x30f0
leaq 0x1e9a(%rip), %rdi      # 0x7965
jmp 0x5ad4
leaq 0x4ded(%rip), %rdi      # 0xa8c1
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30f0
// File: /workspace/github_c_makefile_star2_O3/ethinethin[P]Secret/items.c
// Function: in_room
static int in_room(int room_id, char *adj, char *name)
{
	int i;
	int item_num;
	int count;

	/* find out if given name is ambiguous */
	for (count = 0, i = 0; items[i].item_id != -1; i++) {
		if (strcmp(items[i].item_name,name) == 0 &&
			items[i].location == room_id && items[i].hidden == NO) {
			if (adj == NULL) {
				count++;
				item_num = i;
			} else if (items[i].item_adj != NULL &&
					strcmp(adj,items[i].item_adj) == 0) {
				count = 1;
				item_num = i;
				break;
			}
		}
	}

	/* return results */
	if (count == 0) {
		return -1;
	} else if (count > 1) {
		return -2;
	} else {
		return item_num;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $-0x1, 0x9126(%rip)     # 0xec20
je 0x5b76
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
xorl %ebx, %ebx
leaq 0x914b(%rip), %r13      # 0xec58
xorl %r12d, %r12d
movq -0x30(%r13), %rdi
movq %r14, %rsi
callq 0x3180
testl %eax, %eax
jne 0x5b2d
cmpl %ebp, -0x8(%r13)
jne 0x5b2d
cmpl $0x0, -0x10(%r13)
je 0x5b3c
incl %ebx
cmpl $-0x1, (%r13)
leaq 0x38(%r13), %r13
jne 0x5b10
jmp 0x5b61
testq %r15, %r15
je 0x5b58
movq -0x28(%r13), %rsi
testq %rsi, %rsi
je 0x5b2d
movq %r15, %rdi
callq 0x3180
testl %eax, %eax
jne 0x5b2d
jmp 0x5b7b
incl %r12d
movl %ebx, 0x4(%rsp)
jmp 0x5b2d
cmpl $0x2, %r12d
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
movl 0x4(%rsp), %ebx
cmovgel %eax, %ebx
testl %r12d, %r12d
jne 0x5b7b
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ethinethin[P]Secret/items.c
// Function: unique_item
extern int unique_item(int room_id, char *adj, char *name)
{
	int room;
	int inv;

	if (name == NULL) return -1;

	room = in_room(room_id, adj,name);
	inv = in_inv(adj,name);

	if ((room >= 0 && inv >= 0) || room == -2 || inv == -2) {
		return -2;
	} else if (room == -1 && inv == -1) {
		return -1;
	} else {
		if (inv == -1) inv = room;
		return inv;
	}
}

// Assembly:
testq %rdx, %rdx
je 0x5bed
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x5ae8
movl %eax, %ebx
movq %r15, %rdi
movq %r14, %rsi
callq 0x5bf5
movl %ebx, %ecx
orl %eax, %ecx
setns %cl
cmpl $-0x2, %ebx
sete %dl
cmpl $-0x2, %eax
sete %sil
orb %dl, %sil
orb %cl, %sil
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
jne 0x5be6
cmpl $-0x1, %eax
cmovnel %eax, %ebx
movl %ebx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x5bf2
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ethinethin[P]Secret/items.c
// Function: in_inv
static int in_inv(char *adj, char *name)
{
	int i;
	int item_num;
	int count;
	
	/* find out if given name is ambiguous */
	for (count = 0, i = 0; items[i].item_id != -1; i++) {
		if (strcmp(items[i].item_name,name) == 0 &&
			inventory[i] == YES) {
			if (adj == NULL) {
				count++;
				item_num = i;
			} else if (items[i].item_adj != NULL &&
				strcmp(adj,items[i].item_adj) == 0) {
				count = 1;
				item_num = i;
				break;
			}
		}
	}

	/* return results */
	if (count == 0) {
		return -1;
	} else if (count > 1) {
		return -2;
	} else {
		return item_num;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $-0x1, 0x9019(%rip)     # 0xec20
je 0x5c7b
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0x900f(%rip), %r13      # 0xec28
xorl %r12d, %r12d
movq (%r13), %rdi
movq %rbx, %rsi
callq 0x3180
testl %eax, %eax
jne 0x5c5c
leaq 0x9ffd(%rip), %rax      # 0xfc30
cmpb $0x1, (%r15,%rax)
jne 0x5c5c
testq %r14, %r14
je 0x5c56
movq 0x8(%r13), %rsi
testq %rsi, %rsi
je 0x5c5c
movq %r14, %rdi
callq 0x3180
testl %eax, %eax
jne 0x5c5c
jmp 0x5c91
incl %r12d
movl %r15d, %ebp
incq %r15
cmpl $-0x1, 0x30(%r13)
leaq 0x38(%r13), %r13
jne 0x5c1c
cmpl $0x2, %r12d
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmovgel %eax, %ebp
testl %r12d, %r12d
jne 0x5c80
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r15d, %ebp
jmp 0x5c80
// File: /workspace/github_c_makefile_star2_O3/ethinethin[P]Secret/items.c
// Function: drop_item
extern void drop_item(int room_id, char *word1, char *word2)
{
	char *adj = NULL;
	char *name = NULL;
	int item_num;

	putchar('\n');

	if (word1 == NULL) {
		printf("Drop what?\n");
		return;
	}
	
	/* assign an adjective if possible */
	assign_name(&word1, &word2, &adj, &name);
	
	/* find out if given name is ambiguous */
	item_num = in_inv(adj, name);

	/* if none were found, the item is not in inventory */
	/* if only one was found, it's not ambiguous */
	if (item_num == -1) {
		printf("You do not have a ");
		if (adj != NULL) printf("%s ",adj);
		printf("%s.\n",name);
		return;
	} else if (item_num == -2) {
		printf("Which %s do you want to drop?\n",name);
		return;
	}

	/* drop item */
	items[item_num].location = room_id;
	inventory[item_num] = NO;
	printf("You dropped the ");
	if (items[item_num].item_adj != NULL)
		printf("%s ",items[item_num].item_adj);
	printf("%s.\n",name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebp
movl $0xa, %edi
callq 0x3050
testq %r14, %r14
je 0x5cf6
testq %r15, %r15
movq %r14, %rdi
cmoveq %r15, %rdi
movq %r15, %rbx
cmoveq %r14, %rbx
movq %rbx, %rsi
callq 0x5bf5
cmpl $-0x2, %eax
je 0x5d0c
cmpl $-0x1, %eax
jne 0x5d15
leaq 0x4bfc(%rip), %rdi      # 0xa8da
xorl %eax, %eax
callq 0x30f0
testq %r15, %r15
je 0x5d58
leaq 0x1c79(%rip), %rdi      # 0x796a
movq %r14, %rsi
jmp 0x5d51
leaq 0x4c66(%rip), %rdi      # 0xa963
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3090
leaq 0x4bda(%rip), %rdi      # 0xa8ed
jmp 0x5d5f
cltq
imulq $0x38, %rax, %r14
leaq 0x8efe(%rip), %r15      # 0xec20
movl %ebp, 0x30(%r14,%r15)
leaq 0x9f02(%rip), %rcx      # 0xfc30
movb $0x0, (%rax,%rcx)
leaq 0x4bd3(%rip), %rdi      # 0xa90c
xorl %eax, %eax
callq 0x30f0
movq 0x10(%r14,%r15), %rsi
testq %rsi, %rsi
je 0x5d58
leaq 0x1c19(%rip), %rdi      # 0x796a
xorl %eax, %eax
callq 0x30f0
leaq 0x1c06(%rip), %rdi      # 0x7965
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30f0
// File: /workspace/github_c_makefile_star2_O3/ethinethin[P]Secret/items.c
// Function: look_item
extern void look_item(int room_id, char *word1, char *word2)
{
	char *adj = NULL;
	char *name = NULL;
	int item_num;

	putchar('\n');

	if (word1 == NULL) {
		printf("Look at what?\n");
		return;
	}
	
	/* assign an adjective if possible */
	assign_name(&word1, &word2, &adj, &name);

	/* in location or inventory? */
	item_num = unique_item(room_id, adj, name);

	/* is it ambiguous? */
	if (item_num == -2) {
		printf("Which %s?\n",name);
		return;
	} else if (item_num == -1) {
		printf("There is no ");
		if (adj != NULL) printf("%s ",adj);
		printf("%s here.\n",name);
		return;
	} 
	/* output description */
	printf("%s\n",items[item_num].item_desc_exam);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebp
movl $0xa, %edi
callq 0x3050
testq %r14, %r14
je 0x5dbf
testq %r15, %r15
movq %r14, %rsi
cmoveq %r15, %rsi
movq %r15, %rbx
cmoveq %r14, %rbx
movl %ebp, %edi
movq %rbx, %rdx
callq 0x5b9b
cmpl $-0x1, %eax
je 0x5dc8
cmpl $-0x2, %eax
jne 0x5e07
leaq 0x4b60(%rip), %rdi      # 0xa91d
jmp 0x5df3
leaq 0x4ba8(%rip), %rdi      # 0xa96e
jmp 0x5e19
leaq 0x4ab8(%rip), %rdi      # 0xa887
xorl %eax, %eax
callq 0x30f0
testq %r15, %r15
je 0x5dec
leaq 0x1b88(%rip), %rdi      # 0x796a
movq %r14, %rsi
xorl %eax, %eax
callq 0x30f0
leaq 0x4ba9(%rip), %rdi      # 0xa99c
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30f0
cltq
imulq $0x38, %rax, %rax
leaq 0x8e0c(%rip), %rcx      # 0xec20
movq 0x20(%rax,%rcx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3090
// File: /workspace/github_c_makefile_star2_O3/FastFilter[P]BlockBloomSimulator/src/simpleblockmodel.c
// Function: compute
void compute(size_t HowManyKeys) {
  bool verbose = false;
  printf("Number of keys %zu \n", HowManyKeys);
  printf("Full cache line (512-bits) \n");
  assessBlockSize(HowManyKeys, 512, verbose);
  printf("3/4 cache line (384-bits) \n");
  assessBlockSize(HowManyKeys, 384, verbose);
  printf("Half cache line (256-bits) \n");
  assessBlockSize(HowManyKeys, 256, verbose);
  printf("Half cache line (128-bits) \n");
  assessBlockSize(HowManyKeys, 128, verbose);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x1e13(%rip), %rdi      # 0x437d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
leaq 0x1e17(%rip), %rdi      # 0x4392
callq 0x1070
movl $0x200, %esi            # imm = 0x200
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1630
leaq 0x1e18(%rip), %rdi      # 0x43ae
callq 0x1070
movl $0x180, %esi            # imm = 0x180
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1630
leaq 0x1e18(%rip), %rdi      # 0x43c9
callq 0x1070
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1630
leaq 0x1e19(%rip), %rdi      # 0x43e5
callq 0x1070
movl $0x80, %esi
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
jmp 0x1630
// File: /workspace/github_c_makefile_star2_O3/FastFilter[P]BlockBloomSimulator/src/simpleblockmodel.c
// Function: main
int main() {
  printf("bits per key indicates storage (bits used per key): smaller is "
         "better\n");
  printf("best bits per bucket indicates the number of bits to check per key: "
         "smaller is better\n");
  printf("collision rate is the false negative rate: smaller is better\n");
  printf("In the 'lane' model you have one bit set per lane.\n");
  printf("\n");
  for(size_t i = 10000; i < 1000000000; i*=10) {
    compute(i);
  }

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbx
leaq 0x1e18(%rip), %rdi      # 0x4401
callq 0x1070
leaq 0x1e52(%rip), %rdi      # 0x4447
callq 0x1070
leaq 0x1e9c(%rip), %rdi      # 0x449d
callq 0x1070
leaq 0x1ecd(%rip), %rdi      # 0x44da
callq 0x1070
movl $0xa, %edi
callq 0x1050
movl $0x2710, %ebx           # imm = 0x2710
movq %rbx, %rdi
callq 0x255f
leaq (%rbx,%rbx), %rax
leaq (%rax,%rax,4), %rax
cmpq $0x5f5e100, %rbx        # imm = 0x5F5E100
movq %rax, %rbx
jb 0x2621
xorl %eax, %eax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/cirocosta[P]stress/src/consistent-forking.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { 0 };

	stress_parse_args(argc, argv, &args);
	_STRESS_MUST(args.n > 0, "'n' argument must be at least > 0");
	fork_so_much(args.n);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movl $0x2008, %edx           # imm = 0x2008
movq %r14, %rdi
xorl %esi, %esi
callq 0x10a0
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1509
cmpl $0x0, (%r14)
jle 0x19c8
callq 0x173e
movq 0x2629(%rip), %rbx      # 0x3ff8
movq (%rbx), %rcx
leaq 0x764(%rip), %rdi       # 0x213d
movl $0x9, %esi
movl $0x1, %edx
callq 0x1140
movq (%rbx), %rcx
leaq 0x751(%rip), %rdi       # 0x2143
movl $0x3, %esi
movl $0x1, %edx
callq 0x1140
movq (%rbx), %rcx
leaq 0x766(%rip), %rdi       # 0x2171
movl $0x21, %esi
movl $0x1, %edx
callq 0x1140
movq (%rbx), %rcx
leaq 0x61f(%rip), %rdi       # 0x2043
movl $0x2, %esi
movl $0x1, %edx
callq 0x1140
movq (%rbx), %rdi
leaq 0x609(%rip), %rsi       # 0x2046
leaq 0x6ba(%rip), %rdx       # 0x20fe
xorl %eax, %eax
callq 0x10d0
movq (%rbx), %rdi
leaq 0x60d(%rip), %rsi       # 0x2062
movl $0x47, %edx
xorl %eax, %eax
callq 0x10d0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x10b0
movq (%rbx), %rcx
leaq 0x5f7(%rip), %rdi       # 0x206f
movl $0xa, %esi
movl $0x1, %edx
callq 0x1140
movl $0x1, %edi
callq 0x1130
// File: /workspace/github_c_makefile_star2_O3/Openvario[P]sensord/compdata.c
// Function: sigintHandler
static void sigintHandler(int sig_num)
{
	(void)sig_num;

	signal(SIGINT, sigintHandler);

	// if sensordata from file
	if (fp_sensordata != NULL)
		fclose(fp_sensordata);

	fprintf(stderr, "Exiting ...\n");

	exit(0);
}

// Assembly:
pushq %rax
leaq -0x8(%rip), %rsi        # 0x3090
movl $0x2, %edi
callq 0x1140
leaq 0x30062ff(%rip), %rax   # 0x30093a8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x30b6
callq 0x10b0
movq 0x5f3b(%rip), %rax      # 0x8ff8
movq (%rax), %rcx
leaq 0x2853(%rip), %rdi      # 0x591a
movl $0xc, %esi
movl $0x1, %edx
callq 0x1210
xorl %edi, %edi
callq 0x1200
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: StrMatch
char *StrMatch(char *s, const char *m)
{
   int i,j,k,l;

   k = strlen(s);
   l = strlen(m);

   for (j = 0 ; j <= k-l ; ++j)
   {
      if (s[j] == ';') break;  // don't search comment
      for (i = 0 ; i < l ; ++i)
      {
         if (toupper(s[j+i]) != toupper(m[i])) break;
      }
      if (i == l) return (s + j);
   }
   return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x2110
movq %rax, %rbx
movq %r14, %rdi
callq 0x2110
movq %rbx, %rcx
movq %rax, %r12
cmpl %r12d, %ecx
jge 0x2999
xorl %eax, %eax
jmp 0x2a03
subl %r12d, %ecx
incl %ecx
movl %r12d, %ebp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movq %r15, %rbx
xorl %r13d, %r13d
movq %rcx, (%rsp)
cmpb $0x3b, (%r15,%r13)
je 0x2995
testl %r12d, %r12d
jle 0x29e3
callq 0x2030
movq (%rax), %rcx
xorl %eax, %eax
movsbq (%rbx,%rax), %rdx
movl (%rcx,%rdx,4), %edx
movsbq (%r14,%rax), %rsi
cmpl (%rcx,%rsi,4), %edx
jne 0x29e7
incq %rax
cmpq %rax, %rbp
jne 0x29c7
jmp 0x29fd
xorl %eax, %eax
jmp 0x29eb
movq (%rsp), %rcx
cmpl %r12d, %eax
je 0x29fd
incq %r13
incq %rbx
cmpq %rcx, %r13
jne 0x29b1
jmp 0x2995
addq %r13, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: StrKey
char *StrKey(char *s, const char *m)
{
   char *r = StrMatch(s,m);
   if (r) // match was true
   {
      if ((r > s && isalnum(*(r-1))) ||       // check before
         (isalnum(*(r+strlen(m))))) r = NULL; // check after
   }
   return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2969
testq %rax, %rax
je 0x2a59
movq %rax, %rbx
callq 0x2320
cmpq %r15, %rbx
jbe 0x2a42
movq (%rax), %rcx
movsbq -0x1(%rbx), %rdx
testb $0x8, (%rcx,%rdx,2)
jne 0x2a59
movq (%rax), %r15
movq %r14, %rdi
callq 0x2110
movsbq (%rbx,%rax), %rax
testb $0x8, (%r15,%rax,2)
je 0x2a5b
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: GetSymbol
char *GetSymbol(char *p, char *s)
{
   if (*p == '.') // expand local symbol
   {
      if (Scope[0])
      {
         strcpy(s,Scope);
         s += strlen(s);
         *s++ = *p++;
      }
   }
   if (*p == '_' || isalpha(*p)) while (isym(*p)) *s++ = *p++;
   *s = 0;
   return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %bpl
cmpb $0x2e, %bpl
jne 0x2ae5
cmpb $0x0, 0x222e7(%rip)     # 0x24da0
je 0x2ae5
leaq 0x222de(%rip), %rsi     # 0x24da0
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2110
movb (%r14), %cl
addq %rax, %rbx
incq %rbx
movb %cl, -0x1(%rbx)
movb 0x1(%r14), %bpl
incq %r14
cmpb $0x5f, %bpl
je 0x2b0f
callq 0x2320
movq (%rax), %rax
movsbq %bpl, %rcx
testb $0x4, 0x1(%rax,%rcx,2)
jne 0x2b0f
movb $0x0, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x800000000000401, %r15 # imm = 0x800000000000401
movzbl %bpl, %eax
addl $-0x24, %eax
cmpl $0x3b, %eax
ja 0x2b2b
btq %rax, %r15
jb 0x2b3d
callq 0x2320
movq (%rax), %rax
movsbq %bpl, %rcx
testb $0x8, (%rax,%rcx,2)
je 0x2afe
movb %bpl, (%rbx)
incq %rbx
movb 0x1(%r14), %bpl
incq %r14
jmp 0x2b19
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: GetMacroArg
char *GetMacroArg(char *p, char *s)
{
   p = SkipSpace(p);
   while (*p && *p != ',' && *p != ')') *s++ = *p++;
   *s = 0;
   return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x2b77
callq 0x2320
movq (%rax), %rcx
decq %rbx
movsbq 0x1(%rbx), %rax
incq %rbx
testb $0x20, 0x1(%rcx,%rax,2)
jne 0x2b66
jmp 0x2b79
xorl %eax, %eax
movabsq $0x120000000001, %rcx   # imm = 0x120000000001
cmpb $0x2c, %al
ja 0x2b90
movzbl %al, %edx
btq %rdx, %rcx
jb 0x2b9e
movb %al, (%r14)
incq %r14
movb 0x1(%rbx), %al
incq %rbx
jmp 0x2b83
movb $0x0, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: StrCaseCmp
int StrCaseCmp(const char *a, const char *b)
{
   unsigned int i,l,m;

   l = strlen(a);
   m = strlen(b);

   for (i=0 ; i <= l && i <= m ; ++i)
   {
      if (toupper(a[i]) < toupper(b[i])) return -1;
      if (toupper(a[i]) > toupper(b[i])) return  1;
   }
   return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2110
movq %rax, %r12
movq %rbx, %rdi
callq 0x2110
movq %rax, %r15
cmpl %r15d, %r12d
cmovbl %r12d, %r15d
callq 0x2030
movq (%rax), %rax
xorl %ecx, %ecx
movl %ecx, %edx
movsbq (%r14,%rdx), %rsi
movsbq (%rbx,%rdx), %rdx
movl (%rax,%rdx,4), %edx
cmpl %edx, (%rax,%rsi,4)
jl 0x2c3b
jg 0x2c42
incl %ecx
cmpl %r15d, %ecx
jbe 0x2c1a
xorl %eax, %eax
jmp 0x2c47
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2c47
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: strcmpword
int strcmpword(const char *s1, const char *s2)
{
   int l = strlen(s2);
   int r = StrNCaseCmp(s1,s2,l);
   if (r == 0 && isym(s1[l])) r = 1;
   return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2110
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x2c53
testl %eax, %eax
jne 0x2d3a
movslq %r14d, %rax
movzbl (%rbx,%rax), %ecx
leal -0x24(%rcx), %edx
cmpl $0x3b, %edx
ja 0x2d24
movl $0x1, %eax
movabsq $0x800000000000401, %rsi # imm = 0x800000000000401
btq %rdx, %rsi
jb 0x2d3a
movsbq %cl, %rbx
callq 0x2320
movq (%rax), %rax
movzwl (%rax,%rbx,2), %eax
shrl $0x3, %eax
andl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: SkipHexCode
char *SkipHexCode(char *p)
{
   int l;

   l = strlen(p);
   if (l > 20 && isdigit(p[4]) && isspace(p[5]) &&
       isxdigit(p[6]) && isxdigit(p[7]) &&
       isxdigit(p[8]) && isxdigit(p[9]) &&
       p[0] != ';')
   {
      if (SkipHex) memmove(Line,Line+20,l-19);
      else return (p+20);
   }
   return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2110
movq %rax, %r14
cmpl $0x15, %r14d
jl 0x2dd3
callq 0x2320
movq (%rax), %rax
movsbq 0x4(%rbx), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x2dd3
movsbq 0x5(%rbx), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x2dd3
movsbq 0x6(%rbx), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x2dd3
movsbq 0x7(%rbx), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x2dd3
movsbq 0x8(%rbx), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x2dd3
movsbq 0x9(%rbx), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x2dd3
cmpb $0x3b, (%rbx)
je 0x2dd3
cmpl $0x0, 0x21f9f(%rip)     # 0x24d50
je 0x2dcf
addl $-0x13, %r14d
leaq 0x220e2(%rip), %rdi     # 0x24ea0
leaq 0x220ef(%rip), %rsi     # 0x24eb4
movq %r14, %rdx
callq 0x22a0
jmp 0x2dd3
addq $0x14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ErrorLine
void ErrorLine(char *p)
{
   int i,ep;
   printf("%s\n",Line);
   ep = p - Line;
   if (ep >= 0 && ep < 80)
   {
      for (i=0 ; i < ep ; ++i) printf(" ");
      printf("^\n");
      return;
   }
   ep = p - OpText;
   if (ep >= 0 && ep < 80 && *OpText)
   {
      printf("Operand: %s\n",OpText);
      for (i=0 ; i < ep+9 ; ++i) printf(" ");
      printf("^\n");
      return;
   }

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x220b4(%rip), %r14     # 0x24ea0
movq %r14, %rdi
callq 0x20a0
movl %ebx, %ebp
subl %r14d, %ebp
cmpl $0x4f, %ebp
ja 0x2e19
leaq 0x2209b(%rip), %rax     # 0x24ea0
cmpl %eax, %ebx
je 0x2e5d
movl $0x20, %edi
callq 0x2050
decl %ebp
jne 0x2e09
jmp 0x2e5d
leaq 0x22180(%rip), %rax     # 0x24fa0
subl %eax, %ebx
cmpl $0x4f, %ebx
ja 0x2e6d
cmpb $0x0, 0x22172(%rip)     # 0x24fa0
je 0x2e6d
leaq 0x9406(%rip), %rdi      # 0xc23d
leaq 0x22162(%rip), %rsi     # 0x24fa0
xorl %eax, %eax
callq 0x2130
addl $0x8, %ebx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0x20, %edi
callq 0x2050
incl %ebp
cmpl %ebx, %ebp
jl 0x2e4d
leaq 0xabe1(%rip), %rdi      # 0xda45
popq %rbx
popq %r14
popq %rbp
jmp 0x20a0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/bs9.c
// Function: ErrorMsg
void ErrorMsg(const char *format, ...) {
   va_list args;
   char *buf;

   buf = (char *)MallocOrDie(SIZE_ERRMSG);
   snprintf(buf, SIZE_ERRMSG, "\n*** Error in file %s line %d:\n",
         IncludeStack[IncludeLevel].Src, LiNo);
   va_start(args,format);
   vsnprintf(buf+strlen(buf), SIZE_ERRMSG-strlen(buf), format, args);
   va_end(args);
   fputs(Line, stdout);
   fputs(Line, lf);
   fputs(buf, stdout);
   fputs(buf, lf);
   if (df)
   {
      fputs(Line, df);
      fputs(buf, df);
      // ListSymbols(df,Labels,0,0xffff);
   }
   free(buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r14
leaq 0x20(%rsp), %r13
movq %rsi, 0x8(%r13)
movq %rdx, 0x10(%r13)
movq %rcx, 0x18(%r13)
movq %r8, 0x20(%r13)
movq %r9, 0x28(%r13)
testb %al, %al
je 0x2ed9
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movl $0x400, %r15d           # imm = 0x400
movl $0x400, %edi            # imm = 0x400
movl $0x1, %esi
callq 0x21e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x2834
movslq 0x22b00(%rip), %rax     # 0x25a00
leaq (%rax,%rax,2), %rax
leaq 0x22195(%rip), %rcx     # 0x250a0
movq 0x10(%rcx,%rax,8), %rcx
movl 0x21e41(%rip), %r8d     # 0x24d58
leaq 0x932c(%rip), %rdx      # 0xc24a
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2150
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %r12
movq %rax, (%r12)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r12)
movq %r13, 0x10(%r12)
movq %rbx, %rdi
callq 0x2110
leaq (%rbx,%rax), %rdi
subq %rax, %r15
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x20f0
movq 0xf064(%rip), %r15      # 0x11fd8
movq (%r15), %rsi
leaq 0x21f22(%rip), %r14     # 0x24ea0
movq %r14, %rdi
callq 0x2170
movq 0x22a7b(%rip), %rsi     # 0x25a08
movq %r14, %rdi
callq 0x2170
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x2170
movq 0x22a61(%rip), %rsi     # 0x25a08
movq %rbx, %rdi
callq 0x2170
movq 0x22a5a(%rip), %rsi     # 0x25a10
testq %rsi, %rsi
je 0x2fd6
leaq 0x21ede(%rip), %rdi     # 0x24ea0
callq 0x2170
movq 0x22a42(%rip), %rsi     # 0x25a10
movq %rbx, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2040
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq