LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: adopt
void
adopt(){
	unsigned int i, num;
	Window d1, d2, * wins = NULL;
	XWindowAttributes wa;

	if (XQueryTree(dis, root, &d1, &d2, &wins, &num)) {
		for (i = 0; i < num; i++) {
			if (!XGetWindowAttributes(dis, wins[i], &wa)
			|| wa.override_redirect || XGetTransientForHint(dis, wins[i], &d1))
				continue;
			if (wa.map_state == IsViewable)
				manage(wins[i], &wa);
		}

		for (i = 0; i < num; i++) { /* now the transients */
			if (!XGetWindowAttributes(dis, wins[i], &wa))
				continue;
			if (XGetTransientForHint(dis, wins[i], &d1)
			&& (wa.map_state == IsViewable))
				manage(wins[i], &wa);
		}

		if (wins)
			XFree(wins);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq $0x0, -0x20(%rbp)
movq 0x4bf6(%rip), %rdi      # 0xb500
movq 0x4cdf(%rip), %rsi      # 0xb5f0
leaq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rcx
leaq -0x20(%rbp), %r8
leaq -0x8(%rbp), %r9
callq 0x24b0
cmpl $0x0, %eax
je 0x6a43
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x69b3
movq 0x4bbb(%rip), %rdi      # 0xb500
movq -0x20(%rbp), %rax
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x23f0
cmpl $0x0, %eax
je 0x6987
cmpl $0x0, -0x30(%rbp)
jne 0x6987
movq 0x4b92(%rip), %rdi      # 0xb500
movq -0x20(%rbp), %rax
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
leaq -0x10(%rbp), %rdx
callq 0x2440
cmpl $0x0, %eax
je 0x6989
jmp 0x69a8
cmpl $0x2, -0x4c(%rbp)
jne 0x69a6
movq -0x20(%rbp), %rax
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x62d0
jmp 0x69a8
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6936
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x6a31
movq 0x4b37(%rip), %rdi      # 0xb500
movq -0x20(%rbp), %rax
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x23f0
cmpl $0x0, %eax
jne 0x69e7
jmp 0x6a26
movq 0x4b12(%rip), %rdi      # 0xb500
movq -0x20(%rbp), %rax
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
leaq -0x10(%rbp), %rdx
callq 0x2440
cmpl $0x0, %eax
je 0x6a24
cmpl $0x2, -0x4c(%rbp)
jne 0x6a24
movq -0x20(%rbp), %rax
movl -0x4(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x62d0
jmp 0x6a26
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x69ba
cmpq $0x0, -0x20(%rbp)
je 0x6a41
movq -0x20(%rbp), %rdi
callq 0x2040
jmp 0x6a43
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: handlemsg
void
handlemsg(char* msg){
	char* funcstr, * argstr;
	void (*func)(Arg);
	Arg arg;

	funcstr = strtok(msg, " ");
	argstr = strtok(NULL, " ");

	if (argstr){
		arg.s = argstr;

		if ( (func = str2func(funcstr)) )
			func(arg);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x146e(%rip), %rsi      # 0x8245
callq 0x2390
movq %rax, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x145a(%rip), %rsi      # 0x8245
callq 0x2390
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6e22
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6f20
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6e20
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdi
callq *%rax
jmp 0x6e22
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: runconfig
void
runconfig(){
	int i;
	char shcmd[MAXLEN];

	for (i=0;i < TABLENGTH(progs);i++){
		snprintf(shcmd, slen(progs[i])+1, "%s", progs[i]);

		if (fork() == 0) {
			if (dis)
				close(ConnectionNumber(dis));
			setsid();
			execl("/bin/sh", "/bin/sh", "-c", shcmd, (char *) NULL);
			fprintf(stderr, "sara: failed to execute startup cmd\n");
			exit(EXIT_SUCCESS);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x1, %rax
jae 0x6f17
leaq -0x110(%rbp), %rax
movq %rax, -0x118(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x4677(%rip), %rax      # 0xb4e0
movq (%rax,%rcx,8), %rdi
callq 0x70e0
movq -0x118(%rbp), %rdi
addl $0x1, %eax
movslq %eax, %rsi
movslq -0x4(%rbp), %rcx
leaq 0x4656(%rip), %rax      # 0xb4e0
movq (%rax,%rcx,8), %rcx
leaq 0x1201(%rip), %rdx      # 0x8096
movb $0x0, %al
callq 0x2080
callq 0x2430
cmpl $0x0, %eax
jne 0x6f07
cmpq $0x0, 0x4652(%rip)      # 0xb500
je 0x6ebf
movq 0x4649(%rip), %rax      # 0xb500
movl 0x10(%rax), %edi
callq 0x20a0
callq 0x2090
leaq -0x110(%rbp), %rcx
leaq 0x131d(%rip), %rsi      # 0x81ef
leaq 0x131e(%rip), %rdx      # 0x81f7
xorl %eax, %eax
movl %eax, %r8d
movq %rsi, %rdi
movb $0x0, %al
callq 0x2130
movq 0x40f1(%rip), %rax      # 0xafe0
movq (%rax), %rdi
leaq 0x1301(%rip), %rsi      # 0x81fa
movb $0x0, %al
callq 0x2490
xorl %edi, %edi
callq 0x20e0
jmp 0x6f09
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6e42
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: str2func
void (*str2func(const char* str))(Arg){
	int i;
	for (i=0;i < TABLENGTH(conversions);i++)
		if (STREQ(str, conversions[i].str))
			return conversions[i].func;

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0xf, %rax
jae 0x6f89
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x4474(%rip), %rax      # 0xb3c0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x2370
cmpl $0x0, %eax
jne 0x6f7c
movslq -0x14(%rbp), %rcx
leaq 0x4454(%rip), %rax      # 0xb3c0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6f91
jmp 0x6f7e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6f33
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gitluin[P]sara/src/sara.c
// Function: cleanup
void
cleanup(){
	monitor* m, * tm = mhead;
	const Arg arg = {.s = "-1"};

	/* for an unknown reason, using EACHMON segfaults this */
	for (m=mhead;m;m=m->next){
		changemon(m, NoFocus);
		/* make everything visible */
		toggleview(arg);
		while (curmon->current)
			unmanage(curmon->current, 0);
	}

	XUngrabKey(dis, AnyKey, AnyModifier, root);

	while ( (m = tm) ){
		tm = m->next;
		cleanupmon(m);
	}

	XFreeCursor(dis, cursor);

	XSync(dis, False);
	XSetInputFocus(dis, PointerRoot, RevertToPointerRoot, CurrentTime);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x4651(%rip), %rax      # 0xb600
movq %rax, -0x10(%rbp)
movq 0x3dde(%rip), %rax      # 0xad98
movq %rax, -0x18(%rbp)
movq 0x463b(%rip), %rax      # 0xb600
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7016
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x51e0
movq -0x18(%rbp), %rdi
callq 0x3780
movq 0x453d(%rip), %rax      # 0xb528
cmpq $0x0, 0x28(%rax)
je 0x7006
movq 0x452f(%rip), %rax      # 0xb528
movq 0x28(%rax), %rdi
xorl %esi, %esi
callq 0x6200
jmp 0x6fe4
jmp 0x7008
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6fc9
movq 0x44e3(%rip), %rdi      # 0xb500
movq 0x45cc(%rip), %rcx      # 0xb5f0
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x2190
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x7055
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6120
jmp 0x7030
movq 0x44a4(%rip), %rdi      # 0xb500
movq 0x4595(%rip), %rsi      # 0xb5f8
callq 0x2060
movq 0x4491(%rip), %rdi      # 0xb500
xorl %esi, %esi
callq 0x2330
movq 0x4483(%rip), %rdi      # 0xb500
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2310
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/12-VirtualMemory/test_page_size.c
// Function: main
int main(int argc, char **argv) {
	char c;

	signal(SIGSEGV, handler);
	prev_ptr = ptr = sbrk(0);	// current value of program break.
	sbrk(1);			// force 1-page allocation.
	while(1)
		c = *(++ptr);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xb, %edi
leaq -0x62(%rip), %rsi       # 0x1170
callq 0x1050
xorl %eax, %eax
movl %eax, %edi
callq 0x1040
movq %rax, 0x2e71(%rip)      # 0x4058
movq %rax, 0x2e62(%rip)      # 0x4050
movl $0x1, %edi
callq 0x1040
movq 0x2e59(%rip), %rax      # 0x4058
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x2e4b(%rip)      # 0x4058
movb 0x1(%rax), %al
movb %al, -0x11(%rbp)
jmp 0x11f8
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/challenge.c
// Function: test_erlang_challenge
void
test_erlang_challenge(int counter)
{
	CONFIG* cfg;
	CONS* actor;
	int n;
	int m;

	DBUG_ENTER("test_erlang_challenge");
	cfg = new_configuration(10);
	actor = CFG_ACTOR(cfg, challenge, map_put(NIL, ATOM("n"), NUMBER(counter)));
	CFG_SEND(cfg, actor, actor);
	for (m = 1; m < 1000000; ++m) {
		n = run_configuration(cfg, 1000000);
		if (cfg->q_count <= 0) {
			/* queue empty */
			break;
		}
	}
	TRACE(printf("~%dM messages delivered.\n", m));
	report_actor_usage(cfg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
leaq 0xf79b(%rip), %rax      # 0x1203d
movq %rax, -0x48(%rbp)
leaq 0x14a4b(%rip), %rax     # 0x172f8
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movl $0x6e, -0x3c(%rbp)
leaq 0x11550(%rip), %rax     # 0x13e18
movq %rax, -0x38(%rbp)
leaq 0x1484d(%rip), %rax     # 0x17120
movq %rax, -0x30(%rbp)
leaq 0x14a1a(%rip), %rax     # 0x172f8
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x10b00
movl $0xa, %edi
callq 0x3430
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0xf78f(%rip), %rdi      # 0x1209e
callq 0x9d50
movq %rax, %rsi
movslq -0x4(%rbp), %rdx
shlq $0x2, %rdx
orq $0x3, %rdx
leaq 0x1493e(%rip), %rdi     # 0x17268
callq 0xe490
movq -0x50(%rbp), %rdi
movq %rax, %rdx
leaq -0x3dd(%rip), %rsi      # 0x2560
callq 0x3d60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3e80
movl $0x1, -0x20(%rbp)
cmpl $0xf4240, -0x20(%rbp)   # imm = 0xF4240
jge 0x2991
movq -0x10(%rbp), %rdi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x4780
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jg 0x2984
jmp 0x2991
jmp 0x2986
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x295e
movl -0x20(%rbp), %esi
leaq 0xf6b8(%rip), %rdi      # 0x12053
movb $0x0, %al
callq 0x20d0
movq -0x10(%rbp), %rdi
callq 0x5780
movl $0x7b, -0x3c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x10cd0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/challenge.c
// Function: main
int
main(int argc, char** argv)
{
	int c;
	int counter = 1000;

	DBUG_ENTER("main");
	DBUG_PROCESS(argv[0]);
	while ((c = getopt(argc, argv, "n:#:V")) != EOF) {
		switch(c) {
		case 'n':	counter = atoi(optarg);	break;
		case '#':	DBUG_PUSH(optarg);		break;
		case 'V':	banner();				exit(EXIT_SUCCESS);
		case '?':							usage();
		default:							usage();
		}
	}
	banner();

	test_erlang_challenge(counter);	/* this test involves running the dispatch loop */

	report_cons_stats();
	DBUG_RETURN (exit(EXIT_SUCCESS), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x3e8, -0x18(%rbp)     # imm = 0x3E8
leaq 0xf627(%rip), %rax      # 0x1209b
movq %rax, -0x40(%rbp)
leaq 0x14879(%rip), %rax     # 0x172f8
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0x9a, -0x34(%rbp)
leaq 0x1137e(%rip), %rax     # 0x13e18
movq %rax, -0x30(%rbp)
leaq 0x1467b(%rip), %rax     # 0x17120
movq %rax, -0x28(%rbp)
leaq 0x14848(%rip), %rax     # 0x172f8
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x10b00
leaq 0x1482d(%rip), %rax     # 0x172f8
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x2ae9
leaq 0x1481c(%rip), %rax     # 0x172f8
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x2af7
movq 0x14508(%rip), %rax     # 0x16ff8
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
leaq 0x147f6(%rip), %rax     # 0x172f8
movq (%rax), %rax
movq %rcx, 0x18(%rax)
callq 0x20a0
movl %eax, %ecx
leaq 0x147e1(%rip), %rax     # 0x172f8
movq (%rax), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq 0x147cd(%rip), %rax     # 0x172f8
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0xf560(%rip), %rdx      # 0x120a0
callq 0x21b0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x2bd3
movl -0x14(%rbp), %eax
movl %eax, -0x4c(%rbp)
subl $0x23, %eax
je 0x2b90
jmp 0x2b5e
movl -0x4c(%rbp), %eax
subl $0x3f, %eax
je 0x2bc4
jmp 0x2b68
movl -0x4c(%rbp), %eax
subl $0x56, %eax
je 0x2bb8
jmp 0x2b72
movl -0x4c(%rbp), %eax
subl $0x6e, %eax
jne 0x2bc9
jmp 0x2b7c
movq 0x14455(%rip), %rax     # 0x16fd8
movq (%rax), %rdi
callq 0x21d0
movl %eax, -0x18(%rbp)
jmp 0x2bce
jmp 0x2b92
leaq 0x1475f(%rip), %rax     # 0x172f8
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x9f, 0xc(%rax)
movq 0x1442a(%rip), %rax     # 0x16fd8
movq (%rax), %rdi
callq 0x101a0
jmp 0x2bce
callq 0x2a20
xorl %edi, %edi
callq 0x21f0
callq 0x29f0
callq 0x29f0
jmp 0x2b32
callq 0x2a20
movl -0x18(%rbp), %edi
callq 0x2890
callq 0x29d0
movl $0xaa, -0x34(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x10cd0
xorl %edi, %edi
callq 0x21f0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/rotate.c
// Function: print_seq
static void print_seq(char *seq, int len, int rv, int pos, int line_wd, FILE *fo)
{
    char *s;
    if (!rv) {
        // forward
        for (s = seq, seq += len; s < seq; s++) {
            fputc(*s, fo);
            if ((++pos) % line_wd == 0)
                fputc('\n', fo);
        }
    } else {
         // reverse
        for (s = seq + len - 1; s >= seq; s--) {
            fputc(comp_table[(int) (*s)], fo);
            if ((++pos) % line_wd == 0)
                fputc('\n', fo);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x3ce8
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x3ce6
movq -0x28(%rbp), %rax
movsbl (%rax), %edi
movq -0x20(%rbp), %rsi
callq 0x21a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cltd
idivl -0x18(%rbp)
cmpl $0x0, %edx
jne 0x3cd6
movq -0x20(%rbp), %rsi
movl $0xa, %edi
callq 0x21a0
jmp 0x3cd8
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3c9c
jmp 0x3d55
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x8(%rbp), %rax
jb 0x3d53
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movslq %eax, %rcx
leaq 0x756a(%rip), %rax      # 0xb280
movsbl (%rax,%rcx), %edi
movq -0x20(%rbp), %rsi
callq 0x21a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cltd
idivl -0x18(%rbp)
cmpl $0x0, %edx
jne 0x3d43
movq -0x20(%rbp), %rsi
movl $0xa, %edi
callq 0x21a0
jmp 0x3d45
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3cfb
jmp 0x3d55
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/pread1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);

	memset(buf, 0, sizeof(buf));
	assert(fd >= 0);
	assert(write(fd, buf, sizeof(buf)) == sizeof(buf));
	unlink(tmpfile);

	while (1) {
		assert(pread(fd, buf, BUFLEN, 0) == BUFLEN);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1356(%rip), %rax      # 0x4320
movq %rax, -0x1030(%rbp)
movq 0x1350(%rip), %rax      # 0x4328
movq %rax, -0x1028(%rbp)
movq 0x134a(%rip), %rax      # 0x4330
movq %rax, -0x1020(%rbp)
leaq -0x1030(%rbp), %rdi
callq 0x21b0
movl %eax, -0x1034(%rbp)
leaq -0x1010(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2120
cmpl $0x0, -0x1034(%rbp)
jl 0x301d
jmp 0x303c
leaq 0x1258(%rip), %rdi      # 0x427c
leaq 0x1259(%rip), %rsi      # 0x4284
movl $0x12, %edx
leaq 0x125c(%rip), %rcx      # 0x4293
callq 0x2110
movl -0x1034(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20c0
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x305d
jmp 0x307c
leaq 0x1262(%rip), %rdi      # 0x42c6
leaq 0x1219(%rip), %rsi      # 0x4284
movl $0x13, %edx
leaq 0x121c(%rip), %rcx      # 0x4293
callq 0x2110
leaq -0x1030(%rbp), %rdi
callq 0x2080
movl -0x1034(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
xorl %eax, %eax
movl %eax, %ecx
callq 0x2240
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x30ad
jmp 0x30cc
leaq 0x123d(%rip), %rdi      # 0x42f1
leaq 0x11c9(%rip), %rsi      # 0x4284
movl $0x17, %edx
leaq 0x11cc(%rip), %rcx      # 0x4293
callq 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x3088
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf_sweep.c
// Function: bcf_sweep_init
bcf_sweep_t *bcf_sweep_init(const char *fname)
{
    bcf_sweep_t *sw = (bcf_sweep_t*) calloc(1,sizeof(bcf_sweep_t));
    sw->file = hts_open(fname, "r");
    sw->fp   = hts_get_bgzfp(sw->file);
    if (sw->fp) bgzf_index_build_init(sw->fp);
    sw->hdr  = bcf_hdr_read(sw->file);
    sw->mrec = 1;
    sw->rec  = (bcf1_t*) calloc(sw->mrec,(sizeof(bcf1_t)));
    sw->block_size = 1024*1024*3;
    sw->direction = SW_FWD;
    return sw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x42f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1044cd(%rip), %rsi    # 0x10a2d7
callq 0x326e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x35140
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5e48
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x28790
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xbbe0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x10(%rbp), %rax
movslq 0x2c(%rax), %rdi
movl $0xd0, %esi
callq 0x42f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x300000, 0x1c(%rax)   # imm = 0x300000
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf_sweep.c
// Function: bcf_sweep_destroy
void bcf_sweep_destroy(bcf_sweep_t *sw)
{
    int i;
    for (i=0; i<sw->mrec; i++) bcf_empty1(&sw->rec[i]);
    free(sw->idx);
    free(sw->rec);
    free(sw->lals);
    bcf_hdr_destroy(sw->hdr);
    hts_close(sw->file);
    free(sw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jge 0x5ef5
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0xd0, %rax, %rax
addq %rax, %rdi
callq 0xcae0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5ec3
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x45b0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x45b0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x45b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xb980
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x34800
movq -0x8(%rbp), %rdi
callq 0x45b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf_sweep.c
// Function: bcf_sweep_fwd
bcf1_t *bcf_sweep_fwd(bcf_sweep_t *sw)
{
    if ( sw->direction==SW_BWD ) sw_seek(sw, SW_FWD);

    off_t pos = hts_utell(sw->file);

    bcf1_t *rec = &sw->rec[0];
    int ret = bcf_read1(sw->file, sw->hdr, rec);

    if ( ret!=0 )   // last record, get ready for sweeping backwards
    {
        sw->idx_done = 1;
        if (sw->fp) sw->fp->idx_build_otf = 0;
        sw_seek(sw, SW_BWD);
        return NULL;
    }

    if ( !sw->idx_done )
    {
        if ( !sw->nidx || pos - sw->idx[sw->nidx-1] > sw->block_size )
        {
            sw->nidx++;
            hts_expand(uint64_t, sw->nidx, sw->midx, sw->idx);
            sw->idx[sw->nidx-1] = pos;
        }
    }
    return rec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0x5f71
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x60e0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x354e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xd1d0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x5fee
movq -0x10(%rbp), %rax
movl $0x1, 0x64(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5fd3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl $0x0, 0x58(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x60e0
movq $0x0, -0x8(%rbp)
jmp 0x60d6
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x60ce
movq -0x10(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
je 0x6034
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rcx
movq -0x10(%rbp), %rdx
movl 0x5c(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
subq (%rcx,%rdx,8), %rax
movq -0x10(%rbp), %rcx
movslq 0x1c(%rcx), %rcx
cmpq %rcx, %rax
jbe 0x60cc
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x5c(%rax)
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jle 0x60ad
movq -0x10(%rbp), %rax
cmpl $0x1, 0x5c(%rax)
jl 0x6067
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x6071
movl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6071
movl -0x28(%rbp), %eax
movslq %eax, %rdi
movq -0x10(%rbp), %rax
movslq 0x60(%rax), %rsi
movq -0x10(%rbp), %r9
addq $0x50, %r9
movl $0x4, %edx
movl $0x8, %ecx
xorl %r8d, %r8d
leaq 0xfdfef(%rip), %rax     # 0x10408a
movq %rax, (%rsp)
callq 0x3dfb0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x60(%rax)
jmp 0x60af
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x5c(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x60ce
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf_sweep.c
// Function: sw_seek
static void sw_seek(bcf_sweep_t *sw, int direction)
{
    sw->direction = direction;
    if ( direction==SW_FWD )
        hts_useek(sw->file, sw->idx[0], 0);
    else
    {
        sw->iidx = sw->nidx;
        sw->nrec = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
cmpl $0x0, -0xc(%rbp)
jne 0x611a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rsi
xorl %edx, %edx
callq 0x35470
jmp 0x6133
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf_sweep.c
// Function: bcf_sweep_bwd
bcf1_t *bcf_sweep_bwd(bcf_sweep_t *sw)
{
    if ( sw->direction==SW_FWD ) sw_seek(sw, SW_BWD);
    if ( !sw->nrec ) sw_fill_buffer(sw);
    if ( !sw->nrec ) return NULL;
    return &sw->rec[ --sw->nrec ];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x6164
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x60e0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x6177
movq -0x10(%rbp), %rdi
callq 0x61c0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x618b
movq $0x0, -0x8(%rbp)
jmp 0x61b1
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x28(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x28(%rdx)
movslq %ecx, %rcx
imulq $0xd0, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf_sweep.c
// Function: sw_fill_buffer
static int sw_fill_buffer(bcf_sweep_t *sw)
{
    if ( !sw->iidx ) return 0;
    sw->iidx--;

    int ret = hts_useek(sw->file, sw->idx[sw->iidx], 0);
    assert( ret==0 );

    sw->nrec = 0;
    bcf1_t *rec = &sw->rec[sw->nrec];
    while ( (ret=bcf_read1(sw->file, sw->hdr, rec))==0 )
    {
        bcf_unpack(rec, BCF_UN_STR);

        // if not in the last block, stop at the saved record
        if ( sw->iidx+1 < sw->nidx && sw_rec_equal(sw,rec) ) break;

        sw->nrec++;
        hts_expand0(bcf1_t, sw->nrec+1, sw->mrec, sw->rec);
        rec = &sw->rec[sw->nrec];
    }
    sw_rec_save(sw, &sw->rec[0]);

    return 0; // FIXME: check for errs in this function
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x58(%rax)
jne 0x61e2
movl $0x0, -0x4(%rbp)
jmp 0x6384
movq -0x10(%rbp), %rax
movl 0x58(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x58(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0x35470
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x621c
jmp 0x623b
leaq 0xfde75(%rip), %rdi     # 0x104098
leaq 0xfde75(%rip), %rsi     # 0x10409f
movl $0x5e, %edx
leaq 0xfde75(%rip), %rcx     # 0x1040ab
callq 0x42e0
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x28(%rcx), %rcx
imulq $0xd0, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xd1d0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x636c
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x13d40
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0x5c(%rcx), %eax
jge 0x62c0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x63b0
cmpl $0x0, %eax
je 0x62c0
jmp 0x636c
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jle 0x6347
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
addl $0x1, %eax
cmpl $0x1, %eax
jl 0x62fe
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6308
movl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6308
movl -0x24(%rbp), %eax
movslq %eax, %rdi
movq -0x10(%rbp), %rax
movslq 0x2c(%rax), %rsi
movq -0x10(%rbp), %r9
addq $0x20, %r9
movl $0x4, %edx
movl $0xd0, %ecx
movl $0x1, %r8d
leaq 0xfdd98(%rip), %rax     # 0x1040cd
movq %rax, (%rsp)
callq 0x3dfb0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
jmp 0x6349
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x28(%rcx), %rcx
imulq $0xd0, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x6264
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x64e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf_sweep.c
// Function: sw_rec_equal
static inline int sw_rec_equal(bcf_sweep_t *sw, bcf1_t *rec)
{
    if ( sw->lrid!=rec->rid ) return 0;
    if ( sw->lpos!=rec->pos ) return 0;
    if ( sw->lnals!=rec->n_allele ) return 0;

    char *t = rec->d.allele[sw->lnals-1];
    int len = t - rec->d.allele[0] + 1;
    while ( *t ) { t++; len++; }
    if ( sw->lals_len!=len ) return 0;
    if ( memcmp(sw->lals,rec->d.allele[0],len) ) return 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
je 0x63dc
movl $0x0, -0x4(%rbp)
jmp 0x64c8
movq -0x10(%rbp), %rax
movslq 0x34(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0x63f9
movl $0x0, -0x4(%rbp)
jmp 0x64c8
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
shrq $0x10, %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
cmpl %ecx, %eax
je 0x6423
movl $0x0, -0x4(%rbp)
jmp 0x64c8
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x38(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x88(%rcx), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x647f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x645f
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
cmpl -0x24(%rbp), %eax
je 0x6494
movl $0x0, -0x4(%rbp)
jmp 0x64c8
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq (%rax), %rsi
movslq -0x24(%rbp), %rdx
callq 0x41c0
cmpl $0x0, %eax
je 0x64c1
movl $0x0, -0x4(%rbp)
jmp 0x64c8
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf_sweep.c
// Function: sw_rec_save
static int sw_rec_save(bcf_sweep_t *sw, bcf1_t *rec)
{
    sw->lrid  = rec->rid;
    sw->lpos  = rec->pos;
    sw->lnals = rec->n_allele;

    char *t = rec->d.allele[sw->lnals-1];
    int len = t - rec->d.allele[0] + 1;
    while ( *t ) { t++; len++; }
    sw->lals_len = len;
    hts_expand(char, len, sw->mlals, sw->lals);
    memcpy(sw->lals, rec->d.allele[0], len);

    return 0; // FIXME: check for errs in this function
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x10, %rax
andq $0xffff, %rax           # imm = 0xFFFF
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x38(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x88(%rcx), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6585
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6565
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3c(%rax)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jle 0x65ef
cmpl $0x1, -0x1c(%rbp)
jl 0x65a9
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x65b3
movl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x65b3
movl -0x20(%rbp), %eax
movslq %eax, %rdi
movq -0x8(%rbp), %rax
movslq 0x40(%rax), %rsi
movq -0x8(%rbp), %r9
addq $0x48, %r9
movl $0x4, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
leaq 0xfdaff(%rip), %rax     # 0x1040dc
movq %rax, (%rsp)
callq 0x3dfb0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
jmp 0x65f1
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq (%rax), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x43c0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/examples/gff3sort.c
// Function: main
int main(int argc, const char *argv[])
{
  GtNodeStream *gff3_in_stream, *sort_stream, *gff3_out_stream;
  GtGenomeNode *gn;
  GtError *err;
  int had_err;

  gt_lib_init();
  err = gt_error_new();

  gff3_in_stream = gt_gff3_in_stream_new_unsorted(argc-1, argv+1);
  sort_stream = gt_sort_stream_new(gff3_in_stream);
  gff3_out_stream = gt_gff3_out_stream_new(sort_stream, NULL);

  while (!(had_err = gt_node_stream_next(gff3_out_stream, &gn, err)) && gn)
    gt_genome_node_delete(gn);

  if (had_err)
    fprintf(stderr, "%s: error: %s\n", argv[0], gt_error_get(err));

  gt_node_stream_delete(gff3_out_stream);
  gt_node_stream_delete(sort_stream);
  gt_node_stream_delete(gff3_in_stream);
  gt_error_delete(err);

  if (had_err)
    return EXIT_FAILURE;
  return EXIT_SUCCESS;
}

// Assembly:
subq $0x58, %rsp
movl $0x0, 0x54(%rsp)
movl %edi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
callq 0x8040
callq 0x7c10
movq %rax, 0x20(%rsp)
movl 0x50(%rsp), %edi
subl $0x1, %edi
movq 0x48(%rsp), %rsi
addq $0x8, %rsi
callq 0x1b280
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2a4c0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1c5b0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x28(%rsp), %rsi
callq 0x28420
movl %eax, %ecx
movl %ecx, 0x1c(%rsp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x1b(%rsp)
jne 0x7b62
cmpq $0x0, 0x28(%rsp)
setne %al
movb %al, 0x1b(%rsp)
movb 0x1b(%rsp), %al
testb $0x1, %al
jne 0x7b6c
jmp 0x7b78
movq 0x28(%rsp), %rdi
callq 0x1a870
jmp 0x7b30
cmpl $0x0, 0x1c(%rsp)
je 0x7bc0
movq 0xf2452(%rip), %rax     # 0xf9fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x7e90
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0xc044b(%rip), %rsi     # 0xc8004
movb $0x0, %al
callq 0x76e0
movq 0x30(%rsp), %rdi
callq 0x28340
movq 0x38(%rsp), %rdi
callq 0x28340
movq 0x40(%rsp), %rdi
callq 0x28340
movq 0x20(%rsp), %rdi
callq 0x7ff0
cmpl $0x0, 0x1c(%rsp)
je 0x7bf9
movl $0x1, 0x54(%rsp)
jmp 0x7c01
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/sort_stream.c
// Function: gt_sort_stream_class
const GtNodeStreamClass* gt_sort_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtSortStream),
                                   gt_sort_stream_free,
                                   gt_sort_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x55c50
cmpq $0x0, 0xd1b1a(%rip)     # 0xfbaf8
jne 0x29fff
movl $0x30, %edi
leaq 0x24(%rip), %rsi        # 0x2a010
leaq 0xbd(%rip), %rdx        # 0x2a0b0
callq 0x28170
movq %rax, 0xd1af9(%rip)     # 0xfbaf8
callq 0x55cb0
movq 0xd1aed(%rip), %rax     # 0xfbaf8
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/sort_stream.c
// Function: gt_sort_stream_free
static void gt_sort_stream_free(GtNodeStream *ns)
{
  GtUword i;
  GtSortStream *sort_stream = gt_sort_stream_cast(ns);
  for (i = sort_stream->idx; i < gt_array_size(sort_stream->nodes); i++) {
    gt_genome_node_delete(*(GtGenomeNode**)
                          gt_array_get(sort_stream->nodes, i));
  }
  gt_array_delete(sort_stream->nodes);
  gt_node_stream_delete(sort_stream->in_stream);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
callq 0x29fd0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x28780
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x537e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x2a08e
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x52fd0
movq (%rax), %rdi
callq 0x1a870
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2a03e
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x543f0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x28340
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/sort_stream.c
// Function: gt_sort_stream_new
GtNodeStream* gt_sort_stream_new(GtNodeStream *in_stream)
{
  GtNodeStream *ns = gt_node_stream_create(gt_sort_stream_class(), true);
  GtSortStream *sort_stream = gt_sort_stream_cast(ns);
  gt_assert(in_stream);
  sort_stream->in_stream = gt_node_stream_ref(in_stream);
  sort_stream->sorted = false;
  sort_stream->idx = 0;
  sort_stream->nodes = gt_array_new(sizeof (GtGenomeNode*));
  return ns;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x29fd0
movq %rax, %rdi
movl $0x1, %esi
callq 0x28210
movq %rax, 0x8(%rsp)
callq 0x29fd0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x28780
movq %rax, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2a536
movq 0xcfad3(%rip), %rax     # 0xf9fd8
movq (%rax), %rdi
leaq 0x9db15(%rip), %rsi     # 0xc8024
leaq 0xa4961(%rip), %rdx     # 0xcee77
leaq 0xa4964(%rip), %rcx     # 0xcee81
leaq 0xa4970(%rip), %r8      # 0xcee94
movl $0x80, %r9d
movb $0x0, %al
callq 0x76e0
callq 0x7250
jmp 0x2a538
movq 0x10(%rsp), %rdi
callq 0x282e0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movb $0x0, 0x28(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movl $0x8, %edi
callq 0x52e00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/httpServer.c
// Function: printWithEscapeCharacters
void printWithEscapeCharacters(FILE *out, char *message) {
    unsigned int index = 0;
    char currentCharacter = message[index];

    while (currentCharacter != '\0') {
        switch (currentCharacter) {
        case '\r':
            fputc('\\', out);
            fputc('r', out);
            break;
        case '\n':
            fputc('\\', out);
            fputc('n', out);
            break;
        case '\t':
            fputc('\\', out);
            fputc('t', out);
            break;
        default :
            fputc(currentCharacter, out);
            break;
        }

    index += 1;
    currentCharacter = message[index];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movsbl -0x15(%rbp), %eax
cmpl $0x0, %eax
je 0x1465
movsbl -0x15(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x9, %eax
je 0x141f
jmp 0x13cf
movl -0x1c(%rbp), %eax
subl $0xa, %eax
je 0x1401
jmp 0x13d9
movl -0x1c(%rbp), %eax
subl $0xd, %eax
jne 0x143d
jmp 0x13e3
movq -0x8(%rbp), %rsi
movl $0x5c, %edi
callq 0x1110
movq -0x8(%rbp), %rsi
movl $0x72, %edi
callq 0x1110
jmp 0x144a
movq -0x8(%rbp), %rsi
movl $0x5c, %edi
callq 0x1110
movq -0x8(%rbp), %rsi
movl $0x6e, %edi
callq 0x1110
jmp 0x144a
movq -0x8(%rbp), %rsi
movl $0x5c, %edi
callq 0x1110
movq -0x8(%rbp), %rsi
movl $0x74, %edi
callq 0x1110
jmp 0x144a
movsbl -0x15(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x1110
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
jmp 0x13b4
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/httpServer.c
// Function: checkArguments
void checkArguments(int argc, char **argv, ConfigurationRef config) {
    argc = argc;
    argv = argv;

    if (argc > 2) {
        configLoadFile(config, argv[1]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x2, -0x4(%rbp)
jle 0x14a8
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1af0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/httpServer.c
// Function: setupServer
int setupServer(ConfigurationRef config) {
    int socketNumber = 0;
    int status = 0;
    struct sockaddr_in configuration = (const struct sockaddr_in){0};

    socketNumber = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (socketNumber < 0) {
        exitWithError("setupServer: unable to obtain socket for server",
            EC_SOCKET_FAILURE);
    }

    memset(&configuration, 0, sizeof(configuration));
    configuration.sin_family = AF_INET;
    configuration.sin_addr.s_addr = htonl(INADDR_ANY);
    configuration.sin_port = htons(configPort(config));

    status = bind(socketNumber, (struct sockaddr*)&configuration, sizeof(configuration));
    if (status < 0) {
        exitWithError("setupServer: socket could not be bound with configuration",
            EC_BIND_FAILURE);
    }

    status = listen(socketNumber, BACKLOG_SIZE);
    if (status < 0) {
        exitWithError("setupServer: unable to configure server listening",
            EC_LISTEN_FAILURE);
    }

    return socketNumber;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10f0
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x1210
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x1508
leaq 0x1dbde(%rip), %rdi     # 0x1f0dc
movl $0x2, %esi
callq 0x1350
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10f0
movw $0x2, -0x20(%rbp)
xorl %edi, %edi
callq 0x10e0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bf0
movzwl %ax, %edi
callq 0x10a0
movw %ax, -0x1e(%rbp)
movl -0xc(%rbp), %edi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x1190
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x1568
leaq 0x1dbae(%rip), %rdi     # 0x1f10c
movl $0x3, %esi
callq 0x1350
movl -0xc(%rbp), %edi
movl $0x5, %esi
callq 0x1170
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x158f
leaq 0x1dbc1(%rip), %rdi     # 0x1f146
movl $0x4, %esi
callq 0x1350
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/httpServer.c
// Function: handleClientRequest
void handleClientRequest(int clientSocket, char* request) {
    printf("received message:\n");

    printWithEscapeCharacters(stdout, request);
    printf("\n");

    printf("\n");

    printf("sent message:\n");

    send(clientSocket, defaultHeader, strlen(defaultHeader), 0);
    printWithEscapeCharacters(stdout, defaultHeader);
    printf("\n");

    send(clientSocket, defaultBody, strlen(defaultBody), 0);
    printWithEscapeCharacters(stdout, defaultBody);
    printf("\n");

    printf("\n");

    CLOSESOCKET(clientSocket);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1dbc2(%rip), %rdi     # 0x1f178
movb $0x0, %al
callq 0x10c0
movq 0x22a0c(%rip), %rax     # 0x23fd0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1390
leaq 0x1dbf6(%rip), %rdi     # 0x1f1cd
movb $0x0, %al
callq 0x10c0
leaq 0x1dbe8(%rip), %rdi     # 0x1f1cd
movb $0x0, %al
callq 0x10c0
leaq 0x1db98(%rip), %rdi     # 0x1f18b
movb $0x0, %al
callq 0x10c0
movl -0x4(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq 0x22b19(%rip), %rax     # 0x24120
movq %rax, -0x28(%rbp)
movq 0x22b0e(%rip), %rdi     # 0x24120
callq 0x1090
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x10b0
movq 0x229a1(%rip), %rax     # 0x23fd0
movq (%rax), %rdi
movq 0x22ae7(%rip), %rsi     # 0x24120
callq 0x1390
leaq 0x1db88(%rip), %rdi     # 0x1f1cd
movb $0x0, %al
callq 0x10c0
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq 0x22acf(%rip), %rax     # 0x24128
movq %rax, -0x18(%rbp)
movq 0x22ac4(%rip), %rdi     # 0x24128
callq 0x1090
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x10b0
movq 0x2294f(%rip), %rax     # 0x23fd0
movq (%rax), %rdi
movq 0x22a9d(%rip), %rsi     # 0x24128
callq 0x1390
leaq 0x1db36(%rip), %rdi     # 0x1f1cd
movb $0x0, %al
callq 0x10c0
leaq 0x1db28(%rip), %rdi     # 0x1f1cd
movb $0x0, %al
callq 0x10c0
movl -0x4(%rbp), %edi
callq 0x1100
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/httpServer.c
// Function: main
int main(int argc, char **argv) {
    int serverSocket = 0;
    int clientSocket = 0;
    int receivedCharacters = 0;
    char messageBuffer[BUFFER_SIZE];
    ConfigurationRef config = configCreate();

    checkArguments(argc, argv, config);

    // conditional calls to winsock methods //
    #ifdef _WINDOWS_DETECTED_
      int status = WSAStartup(MAKEWORD(2, 0), &wsaData);
      if (status != 0) {
          exitWithError("main: could not perform startup on Windows",
              EC_WSASTARTUP_FAILURE);
      }
    #endif

    serverSocket = setupServer(config);

    printf("awaiting client connections...\n\n");

    while (1) {
        clientSocket = accept(serverSocket, NULL, NULL);
        printf("client connected!\n\n");

        receivedCharacters = recv(clientSocket, messageBuffer, BUFFER_SIZE, 0);
        if (receivedCharacters < 1) {
            printf("---ERROR RETRIEVING CLIENT REQUEST---\n");
            if (receivedCharacters == 0) printf(" -client already shutdown\n");
            if (receivedCharacters < 0) printf(" -socket error, check errno\n");
            //CLOSESOCKET(clientSocket);
            continue;
        }

        handleClientRequest(clientSocket, messageBuffer);
    }

    CLOSESOCKET(serverSocket);

    // conditional calls to winsock methods //
    #ifdef _WINDOWS_DETECTED_
      WSACleanup();
    #endif

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x17c0
movq %rax, -0x1028(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x1028(%rbp), %rdx
callq 0x1470
movq -0x1028(%rbp), %rdi
callq 0x14b0
movl %eax, -0x14(%rbp)
leaq 0x1da77(%rip), %rdi     # 0x1f19a
movb $0x0, %al
callq 0x10c0
movl -0x14(%rbp), %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x11c0
movl %eax, -0x18(%rbp)
leaq 0x1da78(%rip), %rdi     # 0x1f1bb
movb $0x0, %al
callq 0x10c0
movl -0x18(%rbp), %edi
leaq -0x1020(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
xorl %ecx, %ecx
callq 0x1040
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jge 0x17a1
leaq 0x1da5f(%rip), %rdi     # 0x1f1cf
movb $0x0, %al
callq 0x10c0
cmpl $0x0, -0x1c(%rbp)
jne 0x178b
leaq 0x1da72(%rip), %rdi     # 0x1f1f6
movb $0x0, %al
callq 0x10c0
cmpl $0x0, -0x1c(%rbp)
jge 0x179f
leaq 0x1da79(%rip), %rdi     # 0x1f211
movb $0x0, %al
callq 0x10c0
jmp 0x172a
movl -0x18(%rbp), %edi
leaq -0x1020(%rbp), %rsi
callq 0x15a0
jmp 0x172a
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/mijallen[P]SimpleHTTPServer/config.c
// Function: configCreate
ConfigurationRef configCreate() {
    ConfigurationRef config = malloc(sizeof(struct Configuration));
    if (config != NULL) {
        config->port = 8080;
    }

    return config;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2, %edi
callq 0x1160
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x17e6
movq -0x8(%rbp), %rax
movw $0x1f90, (%rax)         # imm = 0x1F90
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq