LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/serge-404[P]CPM32/cpm.c
// Function: w32_gotodxy
void w32_gotodxy( int dx, int dy)
{
#ifdef __linux__
	int x,y,sx=80,sy=24;
#ifdef TIOCGSIZE
    struct ttysize ts;
    ioctl(STDIN_FILENO, TIOCGSIZE, &ts);
    sx = ts.ts_cols;
    sy = ts.ts_lines;
#elif defined(TIOCGWINSZ)
    struct winsize ts;
    ioctl(STDIN_FILENO, TIOCGWINSZ, &ts);
    sx = ts.ws_col;
    sy = ts.ws_row;
#endif /* TIOCGSIZE */
	getCursorPosition(&y,&x);
	dx+=x;
	dy+=y;
    if ( dx >= sx) dx = sx - 1;
    else if ( dx < 0) dx = 0;
    if ( dy >= sy) dy = sy - 1;
    else if ( dy < 0) dy = 0;
	moveTo((short)dy,(short)dx);
	fflush(stdout);
#else
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    GetConsoleScreenBufferInfo( hConOut, &csbi);
    dx += csbi.dwCursorPosition.X;
    dy += csbi.dwCursorPosition.Y;
    if ( dx >= csbi.dwSize.X) dx = csbi.dwSize.X - 1;
    else if ( dx < 0) dx = 0;
    if ( dy >= csbi.dwSize.Y) dy = csbi.dwSize.Y - 1;
    else if ( dy < 0) dy = 0;
    csbi.dwCursorPosition.X = (short)dx;
    csbi.dwCursorPosition.Y = (short)dy;
    SetConsoleCursorPosition( hConOut, csbi.dwCursorPosition);
#endif	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x50, -0x14(%rbp)
movl $0x18, -0x18(%rbp)
xorl %edi, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0x20(%rbp), %rdx
movb $0x0, %al
callq 0x2170
movzwl -0x1e(%rbp), %eax
movl %eax, -0x14(%rbp)
movzwl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x103f0
movl -0xc(%rbp), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x10(%rbp), %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x1052e
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1053d
cmpl $0x0, -0x4(%rbp)
jge 0x1053b
movl $0x0, -0x4(%rbp)
jmp 0x1053d
movl -0x8(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x10550
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1055f
cmpl $0x0, -0x8(%rbp)
jge 0x1055d
movl $0x0, -0x8(%rbp)
jmp 0x1055f
movl -0x8(%rbp), %eax
movswl %ax, %edi
movl -0x4(%rbp), %eax
movswl %ax, %esi
callq 0x10380
movq 0xaa59(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
callq 0x22c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/serge-404[P]CPM32/cpm.c
// Function: w32_scroll
void w32_scroll( int len)
{
#ifdef __linux__
	if (len<0) {
		while (len++<0)
			insLine();
	} else {
		while (len-->0)
			delLine();
	}								/* TODO */
#else
		COORD dst;
    SMALL_RECT src;
    CHAR_INFO chinfo;
    CONSOLE_SCREEN_BUFFER_INFO csbi;

    GetConsoleScreenBufferInfo( hConOut, &csbi);
    src.Left = 0; 
    src.Top = (short)(csbi.dwCursorPosition.Y + (( len >= 0) ? len : 0));
    src.Right = (short)(csbi.dwSize.X - 1);
    src.Bottom = (short)(csbi.dwSize.Y - 1);
    dst.X = 0;
    dst.Y = (short)(csbi.dwCursorPosition.Y - ((len >= 0) ? 0 : len));
    chinfo.Char.AsciiChar = ' ';
    chinfo.Attributes = csbi.wAttributes;

    ScrollConsoleScreenBuffer( hConOut, &src, NULL, dst, &chinfo);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x1077c
jmp 0x10763
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, %eax
jge 0x1077a
callq 0x135e0
jmp 0x10763
jmp 0x10797
jmp 0x1077e
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, %eax
jle 0x10795
callq 0x13600
jmp 0x1077e
jmp 0x10797
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/serge-404[P]CPM32/cpm.c
// Function: toggleInvertion
void toggleInvertion(void) {
	if (inverted) {
		setTextNoInverted();
	    inverted=FALSE;
	}
	else {
		setTextInverted();
	    inverted=TRUE;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x10ab75(%rip)    # 0x11b4b0
je 0x1094e
callq 0x13620
movl $0x0, 0x10ab64(%rip)    # 0x11b4b0
jmp 0x1095d
callq 0x13640
movl $0x1, 0x10ab53(%rip)    # 0x11b4b0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/serge-404[P]CPM32/cpm.c
// Function: cpm_gets
byte cpm_gets( byte *buf)
{
    int i;
	reset_terminal_mode();
	if ( fgets((char *)buf + 2, buf[ 0], stdin) == NULL) {
		set_conio_terminal_mode();
		if ( --eofcount == 0) {
			cpm_conio_restore();
			exit( 0);
		}
		strcpy((char *)buf + 2, "\x1a\n");
    }
	set_conio_terminal_mode();
    i = strlen((char *)buf + 2);
    if (i > 0) i--;
    buf[ 2 + i] = '\r'; buf[ 1] = (byte)i;
    if ( conout && conin) w32_up();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x2500
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
movq -0x8(%rbp), %rax
movzbl (%rax), %esi
movq 0xa311(%rip), %rax      # 0x1afd8
movq (%rax), %rdx
callq 0x21e0
cmpq $0x0, %rax
jne 0x10d0e
callq 0x2560
movl 0xa568(%rip), %eax      # 0x1b248
addl $-0x1, %eax
movl %eax, 0xa55f(%rip)      # 0x1b248
cmpl $0x0, %eax
jne 0x10cfa
callq 0x10980
xorl %edi, %edi
callq 0x23c0
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
leaq 0x786c(%rip), %rsi      # 0x18575
callq 0x2090
callq 0x2560
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
callq 0x20f0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x10d32
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb $0xd, (%rax,%rcx)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
cmpl $0x0, 0x10cd9a(%rip)    # 0x11daf0
je 0x10d66
cmpl $0x0, 0x10cd95(%rip)    # 0x11daf4
je 0x10d66
callq 0x107a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/warnp/main.c
// Function: check_stderr_syslog
static void
check_stderr_syslog(const char * extra_message)
{

	/* Print messages. */
	print_stuff(extra_message);

	/* Switch to syslog. */
	warnp_syslog(1);
	print_stuff(extra_message);

	/* Back to stderr. */
	warnp_syslog(0);
	warn0("back to stderr");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17d0
movl $0x1, %edi
callq 0x1f60
movq -0x8(%rbp), %rdi
callq 0x17d0
xorl %edi, %edi
callq 0x1f60
leaq 0xa9d(%rip), %rdi       # 0x2153
movb $0x0, %al
callq 0x1d70
callq 0x1070
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/warnp/main.c
// Function: check_multithread
static int
check_multithread(void)
{
	pthread_t thr[NUM_THREADS];
	int nums[NUM_THREADS];
	int i;
	int rc;

	/* Create threads. */
	for (i = 0; i < NUM_THREADS; i++) {
		nums[i] = i;
		if ((rc = pthread_create(&thr[i], NULL, workthread, &nums[i]))
		    != 0) {
			warn0("pthread_create: %s", strerror(rc));
			goto err0;
		}
	}

	/* Wait until they're finished. */
	for (i = 0; i < NUM_THREADS; i++) {
		if ((rc = pthread_join(thr[i], NULL)) != 0) {
			warn0("pthread_join: %s", strerror(rc));
			goto err0;
		}
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x30(%rbp)
cmpl $0x3, -0x30(%rbp)
jge 0x175b
movl -0x30(%rbp), %ecx
movslq -0x30(%rbp), %rax
movl %ecx, -0x2c(%rbp,%rax,4)
movslq -0x30(%rbp), %rax
leaq -0x20(%rbp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
movslq -0x30(%rbp), %rax
leaq -0x2c(%rbp), %rcx
shlq $0x2, %rax
addq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x2b7(%rip), %rdx       # 0x19d0
callq 0x10e0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x174e
jmp 0x1728
movl -0x34(%rbp), %edi
callq 0x1150
movq %rax, %rsi
leaq 0xa4e(%rip), %rdi       # 0x2188
movb $0x0, %al
callq 0x1d70
callq 0x1070
movl $0x0, (%rax)
jmp 0x17c0
jmp 0x1750
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x16df
movl $0x0, -0x30(%rbp)
cmpl $0x3, -0x30(%rbp)
jge 0x17b7
movslq -0x30(%rbp), %rax
movq -0x20(%rbp,%rax,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1130
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x17aa
jmp 0x1784
movl -0x34(%rbp), %edi
callq 0x1150
movq %rax, %rsi
leaq 0xa05(%rip), %rdi       # 0x219b
movb $0x0, %al
callq 0x1d70
callq 0x1070
movl $0x0, (%rax)
jmp 0x17c0
jmp 0x17ac
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1762
movl $0x0, -0x4(%rbp)
jmp 0x17c7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/warnp/main.c
// Function: print_stuff
static void
print_stuff(const char * extra_message)
{

	/* Output the nonce word; also warn0 with a formatted message. */
	warn0("begin output, nonce=%s", extra_message);

	/* Output NULL. */
	warn0(NULL);

	/* Do errno=2 first, so that we don't repeat the same message. */
	errno = 2;
	warnp(NULL);
	errno = 0;
	warnp(NULL);

	/* Output messages involving warnp with a formatted message. */
	errno = 0;
	warnp("warnp errno %d", 0);

	errno = 2;
	warnp("warnp errno %d", 2);

	/* Output long message. */
	print_long_message();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x97b(%rip), %rdi       # 0x2162
movb $0x0, %al
callq 0x1d70
callq 0x1070
movl $0x0, (%rax)
jmp 0x17fb
xorl %eax, %eax
movl %eax, %edi
movb $0x0, %al
callq 0x1d70
callq 0x1070
movl $0x0, (%rax)
callq 0x1070
movl $0x2, (%rax)
callq 0x1070
cmpl $0x0, (%rax)
je 0x183e
xorl %eax, %eax
movl %eax, %edi
movb $0x0, %al
callq 0x1b20
callq 0x1070
movl $0x0, (%rax)
jmp 0x1849
xorl %eax, %eax
movl %eax, %edi
movb $0x0, %al
callq 0x1d70
jmp 0x184b
callq 0x1070
movl $0x0, (%rax)
callq 0x1070
cmpl $0x0, (%rax)
je 0x1878
xorl %eax, %eax
movl %eax, %edi
movb $0x0, %al
callq 0x1b20
callq 0x1070
movl $0x0, (%rax)
jmp 0x1883
xorl %eax, %eax
movl %eax, %edi
movb $0x0, %al
callq 0x1d70
jmp 0x1885
callq 0x1070
movl $0x0, (%rax)
callq 0x1070
cmpl $0x0, (%rax)
je 0x18b7
leaq 0x8d8(%rip), %rdi       # 0x2179
xorl %esi, %esi
movb $0x0, %al
callq 0x1b20
callq 0x1070
movl $0x0, (%rax)
jmp 0x18c7
leaq 0x8bb(%rip), %rdi       # 0x2179
xorl %esi, %esi
movb $0x0, %al
callq 0x1d70
jmp 0x18c9
callq 0x1070
movl $0x2, (%rax)
callq 0x1070
cmpl $0x0, (%rax)
je 0x18fe
leaq 0x894(%rip), %rdi       # 0x2179
movl $0x2, %esi
movb $0x0, %al
callq 0x1b20
callq 0x1070
movl $0x0, (%rax)
jmp 0x1911
leaq 0x874(%rip), %rdi       # 0x2179
movl $0x2, %esi
movb $0x0, %al
callq 0x1d70
jmp 0x1913
callq 0x1920
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/warnp/main.c
// Function: print_long_message
static void
print_long_message(void)
{
	char message[301];
	int i, j;

	/* Construct message: "a_________b_________c_" up to "_~_________". */
	for (i = 0; i < 30; i++) {
		message[10*i] = (char)('a' + i);
		for (j = 1; j < 10; j++) {
			message[10*i + j] = '_';
		}
	}
	message[300] = '\0';

	/* Print long message. */
	warn0(message);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl $0x0, -0x134(%rbp)
cmpl $0x1e, -0x134(%rbp)
jge 0x19a7
movl -0x134(%rbp), %eax
addl $0x61, %eax
movb %al, %cl
imull $0xa, -0x134(%rbp), %eax
cltq
movb %cl, -0x130(%rbp,%rax)
movl $0x1, -0x138(%rbp)
cmpl $0xa, -0x138(%rbp)
jge 0x1994
imull $0xa, -0x134(%rbp), %eax
addl -0x138(%rbp), %eax
cltq
movb $0x5f, -0x130(%rbp,%rax)
movl -0x138(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x138(%rbp)
jmp 0x1963
jmp 0x1996
movl -0x134(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x134(%rbp)
jmp 0x1935
movb $0x0, -0x4(%rbp)
leaq -0x130(%rbp), %rdi
movb $0x0, %al
callq 0x1d70
callq 0x1070
movl $0x0, (%rax)
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/warnp/main.c
// Function: workthread
static void *
workthread(void * cookie)
{
	int num = *((int *)cookie);
	int i;

	/* Output a bunch of messages. */
	for (i = 0; i < 10; i++) {
		errno = ENOENT;
		warnp("thread #%d val %d", num, i);
	}

	/* Success! */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0xa, -0x10(%rbp)
jge 0x1a4b
callq 0x1070
movl $0x2, (%rax)
callq 0x1070
cmpl $0x0, (%rax)
je 0x1a28
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x798(%rip), %rdi       # 0x21ac
movb $0x0, %al
callq 0x1b20
callq 0x1070
movl $0x0, (%rax)
jmp 0x1a3c
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x777(%rip), %rdi       # 0x21ac
movb $0x0, %al
callq 0x1d70
jmp 0x1a3e
jmp 0x1a40
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x19ec
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]jread/test/test.c
// Function: handler
void handler(jr_type_t type, const jr_str_t* data, void* user_data) {
    switch (type) {
        case jr_type_error:
            printf("ERROR: '%.*s'\n", data->len, data->cstr);
            exit(1);
        default:
            return;
    }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movl 0x14(%rsp), %eax
testl %eax, %eax
jne 0x1f223
jmp 0x1f1fb
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
leaq 0xdfe(%rip), %rdi       # 0x20010
movb $0x0, %al
callq 0x1f070
movl $0x1, %edi
callq 0x1f0d0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]jread/test/test.c
// Function: main
int main(int argc, char *argv[]) {
    if (argc != 2)
        return 1;
    FILE* fp = fopen(argv[1], "rb");
    if (!fp)
        return 1;
    fseek(fp, 0, SEEK_END);
    int32_t size = (int32_t)ftell(fp);
    fseek(fp, 0, SEEK_SET);

    char* buffer = (char*)malloc(size + 1);
    if (fread(buffer, 1, size, fp) < size)
        return 1;
    buffer[size] = '\0';
    fclose(fp);
    clock_t start = clock();
    jr_read(&handler, buffer, 0);
    printf("%.4f\n", (double)(clock() - start) / CLOCKS_PER_SEC);
    free(buffer);
    return 0;
}

// Assembly:
subq $0x38, %rsp
movl $0x0, 0x34(%rsp)
movl %edi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpl $0x2, 0x30(%rsp)
je 0x1f259
movl $0x1, 0x34(%rsp)
jmp 0x1f36c
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0xdb6(%rip), %rsi       # 0x2001f
callq 0x1f0c0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x1f288
movl $0x1, 0x34(%rsp)
jmp 0x1f36c
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1f0b0
movq 0x20(%rsp), %rdi
callq 0x1f090
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1f0b0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x1f0a0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl $0x1, %esi
callq 0x1f040
movslq 0x1c(%rsp), %rcx
cmpq %rcx, %rax
jae 0x1f2fa
movl $0x1, 0x34(%rsp)
jmp 0x1f36c
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x20(%rsp), %rdi
callq 0x1f060
callq 0x1f050
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rsi
leaq -0x148(%rip), %rdi      # 0x1f1e0
xorl %eax, %eax
movl %eax, %edx
callq 0x1f380
callq 0x1f050
subq 0x8(%rsp), %rax
cvtsi2sd %rax, %xmm0
movsd 0xcc0(%rip), %xmm1      # 0x20008
divsd %xmm1, %xmm0
leaq 0xccf(%rip), %rdi       # 0x20022
movb $0x1, %al
callq 0x1f070
movq 0x10(%rsp), %rdi
callq 0x1f030
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/cond.c
// Function: wait_thread
void *wait_thread(void *arg)
{
	(void)arg;
	sleep(g_hibernation);

	pthread_mutex_lock(&g_data.mutex);
	g_data.value = 1; /* main's predicate */
	pthread_cond_signal(&g_data.cond);
	pthread_mutex_unlock(&g_data.mutex);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x2e96(%rip), %edi      # 0x4078
callq 0x10b0
leaq 0x2e9a(%rip), %rdi      # 0x4088
callq 0x10c0
movl $0x1, 0x2ee3(%rip)      # 0x40e0
leaq 0x2e84(%rip), %rdi      # 0x4088
addq $0x28, %rdi
callq 0x1050
leaq 0x2e74(%rip), %rdi      # 0x4088
callq 0x1070
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/cond.c
// Function: main
int main(int argc, const char **argv)
{
	pthread_t wait_thread_id;
	struct timespec timeout = {0};

	if (argc > 1)
		g_hibernation = atoi(argv[1]);

	pthread_create(&wait_thread_id, NULL, wait_thread, NULL);

	/* if g_hibernation > 2 this will time out */
	timeout.tv_sec = time(NULL)+2;

	pthread_mutex_lock(&g_data.mutex);
	while (g_data.value == 0)
	{
		int status = pthread_cond_timedwait(
			&g_data.cond, &g_data.mutex, &timeout);
		if (status == ETIMEDOUT)
		{
			puts("Condition var timeout");
			break;
		}
	}
	if (g_data.value != 0)
		puts("Condition var got signaled");
	pthread_mutex_unlock(&g_data.mutex);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1040
cmpl $0x1, -0x8(%rbp)
jle 0x126f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10a0
movl %eax, 0x2e09(%rip)      # 0x4078
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xae(%rip), %rdx       # 0x11d0
movq %rcx, %rsi
callq 0x1080
xorl %eax, %eax
movl %eax, %edi
callq 0x1060
addq $0x2, %rax
movq %rax, -0x28(%rbp)
leaq 0x2dea(%rip), %rdi      # 0x4088
callq 0x10c0
cmpl $0x0, 0x2e36(%rip)      # 0x40e0
jne 0x12dc
leaq 0x2dd5(%rip), %rsi      # 0x4088
movq %rsi, %rdi
addq $0x28, %rdi
leaq -0x28(%rbp), %rdx
callq 0x1090
movl %eax, -0x2c(%rbp)
cmpl $0x6e, -0x2c(%rbp)
jne 0x12da
leaq 0xd31(%rip), %rdi       # 0x2004
callq 0x1030
jmp 0x12dc
jmp 0x12a3
cmpl $0x0, 0x2dfd(%rip)      # 0x40e0
je 0x12f1
leaq 0xd2e(%rip), %rdi       # 0x201a
callq 0x1030
leaq 0x2d90(%rip), %rdi      # 0x4088
callq 0x1070
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_04/atime.c
// Function: main
int main(int argc, char *argv[])
{
	struct tm tm;
	struct timespec times[2];
	char *c;
	int fd;
        int ret;

	/* Do not touch the last modification time! */
	times[1].tv_nsec = UTIME_OMIT;

        if (argc < 2) {
                fprintf(stderr, "usage: %s <file> [<newtime>]\n",
                        argv[0]);
                return -1;
        } else if (argc > 2) {
		/* Parse the new time as: Mmm DD HH:MM:SS YYYY*/
		c = strptime(argv[2],
			"%b %d %H:%M:%S %Y", &tm);
		if (c == NULL || *c != '\0') {
			fprintf(stderr, "invalid time!\n");
			return -1;	
		}
		times[0].tv_sec = mktime(&tm);
		times[0].tv_nsec = 0;
	} else {
		/* Set the current time */
		times[0].tv_nsec = UTIME_NOW;
	}

	ret = open(argv[1], O_RDONLY);
	if (ret < 0) {
		perror("open");
		return -1;
	}
	fd = ret;

	ret = futimens(fd, times);
	if (ret < 0) {
		perror("open");
		return -1;
	}

	close(fd);

        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x3ffffffe, -0x58(%rbp) # imm = 0x3FFFFFFE
cmpl $0x2, -0x8(%rbp)
jge 0x11f2
movq 0x2e2a(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xe25(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12da
cmpl $0x2, -0x8(%rbp)
jle 0x1262
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0xe1b(%rip), %rsi       # 0x2022
leaq -0x48(%rbp), %rdx
callq 0x1090
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x78(%rbp)
je 0x1227
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x124b
movq 0x2dca(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xdfc(%rip), %rsi       # 0x2034
movb $0x0, %al
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12da
leaq -0x48(%rbp), %rdi
callq 0x1050
movq %rax, -0x70(%rbp)
movq $0x0, -0x68(%rbp)
jmp 0x126a
movq $0x3fffffff, -0x68(%rbp) # imm = 0x3FFFFFFF
jmp 0x126c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x1060
movl %eax, -0x80(%rbp)
cmpl $0x0, -0x80(%rbp)
jge 0x129b
leaq 0xdb6(%rip), %rdi       # 0x2043
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12da
movl -0x80(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %edi
leaq -0x70(%rbp), %rsi
callq 0x1080
movl %eax, -0x80(%rbp)
cmpl $0x0, -0x80(%rbp)
jge 0x12cb
leaq 0xd86(%rip), %rdi       # 0x2043
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12da
movl -0x7c(%rbp), %edi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sos22[P]unexec/tests/sigsafe.c
// Function: main
int main() {
    close(mkstemp(path));
    signal(SIGALRM, sighandler);
    double start = now();
    double last = now();
    while (true) {
        double cntr = now();
        if (cntr - start > 10) break;
        assert(cntr - last < 1);
        printf("iter %d time %f\n", nr_signals, cntr - last);
        last = cntr;
        struct itimerval itimer = {
            .it_interval = {
                .tv_sec = 0,
                .tv_usec = 10000, },
            .it_value = {
                .tv_sec = 0,
                .tv_usec = 10000, } };
        signalled = false;
        if (setitimer(ITIMER_REAL, &itimer, NULL) < 0) err(1, "setitimer");
        while (!signalled) {
            unsigned r = random() % 100000;
            void * ptr = malloc(r);
            free(ptr); } }
    unlink(path);
    return 0; }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x2e72(%rip), %rdi      # 0x4098
callq 0x10d0
movl %eax, %edi
callq 0x1080
movl $0xe, %edi
leaq 0x152(%rip), %rsi       # 0x1390
callq 0x1090
callq 0x1450
movsd %xmm0, -0x10(%rbp)
callq 0x1450
movsd %xmm0, -0x18(%rbp)
callq 0x1450
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd 0xd95(%rip), %xmm1      # 0x2008
ucomisd %xmm1, %xmm0
jbe 0x127e
jmp 0x137b
movsd -0x20(%rbp), %xmm1
subsd -0x18(%rbp), %xmm1
movsd 0xd80(%rip), %xmm0      # 0x2010
ucomisd %xmm1, %xmm0
jbe 0x1298
jmp 0x12b7
leaq 0xd81(%rip), %rdi       # 0x2020
leaq 0xd8a(%rip), %rsi       # 0x2030
movl $0x2a, %edx
leaq 0xd8e(%rip), %rcx       # 0x2040
callq 0x1070
movl 0x2def(%rip), %esi      # 0x40ac
movsd -0x20(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
leaq 0xd7d(%rip), %rdi       # 0x204b
movb $0x1, %al
callq 0x1050
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq 0xdb2(%rip), %rax       # 0x2098
movq %rax, -0x40(%rbp)
movq 0xdaf(%rip), %rax       # 0x20a0
movq %rax, -0x38(%rbp)
movq 0xdac(%rip), %rax       # 0x20a8
movq %rax, -0x30(%rbp)
movq 0xda9(%rip), %rax       # 0x20b0
movq %rax, -0x28(%rbp)
movb $0x0, 0x2d9e(%rip)      # 0x40b0
xorl %edi, %edi
leaq -0x40(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x10e0
cmpl $0x0, %eax
jge 0x1339
movl $0x1, %edi
leaq 0xd2a(%rip), %rsi       # 0x205c
movb $0x0, %al
callq 0x10b0
jmp 0x133b
movb 0x2d6f(%rip), %al       # 0x40b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1349
jmp 0x1376
callq 0x10a0
movl $0x186a0, %ecx          # imm = 0x186A0
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, %edi
callq 0x10c0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1030
jmp 0x133b
jmp 0x1257
leaq 0x2d16(%rip), %rdi      # 0x4098
callq 0x1040
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sos22[P]unexec/tests/sigsafe.c
// Function: sighandler
static void sighandler(int ignore __attribute__((unused))) {
    assert(!signalled);
    nr_signals++;
    int r = unexec(path, NULL);
    if (r < 0) err(1, "unexec");
    if (r == 1) {
        execl(path, path, NULL);
        err(1, "execl %s", path); }
    unlink(path);
    signalled = true; }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movb 0x2d0f(%rip), %al       # 0x40b0
testb $0x1, %al
jne 0x13a7
jmp 0x13c6
leaq 0xcb8(%rip), %rdi       # 0x2066
leaq 0xc7b(%rip), %rsi       # 0x2030
movl $0x18, %edx
leaq 0xcb0(%rip), %rcx       # 0x2071
callq 0x1070
movl 0x2ce0(%rip), %eax      # 0x40ac
addl $0x1, %eax
movl %eax, 0x2cd7(%rip)      # 0x40ac
leaq 0x2cbc(%rip), %rdi      # 0x4098
xorl %eax, %eax
movl %eax, %esi
callq 0x10f0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x1401
movl $0x1, %edi
leaq 0xc8c(%rip), %rsi       # 0x2086
movb $0x0, %al
callq 0x10b0
cmpl $0x1, -0x8(%rbp)
jne 0x1436
leaq 0x2c8a(%rip), %rsi      # 0x4098
xorl %eax, %eax
movl %eax, %edx
movq %rsi, %rdi
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
leaq 0xc65(%rip), %rsi       # 0x208d
leaq 0x2c69(%rip), %rdx      # 0x4098
movb $0x0, %al
callq 0x10b0
leaq 0x2c5b(%rip), %rdi      # 0x4098
callq 0x1040
movb $0x1, 0x2c67(%rip)      # 0x40b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/zero/zero.c
// Function: readAmplitude
static int
readAmplitude(FILE *in,FILE *out,RRA *h)
    {
    int i,amp;

    if (Spot == -1)
        {
        Remaining = SIZE;
        /* fill the window */
        for (i = 0; i < SIZE; ++i)
            Window[i] = readRRAAmplitude(in,out,h->bitsPerSample,outputComment);
        }

    ++Spot;
    amp = Window[Spot%SIZE2];
    //printf("reading index %d (%d): %d\n",Spot,Spot%SIZE2,amp);

    Window[(Spot+SIZE)%SIZE2] = 
            readRRAAmplitude(in,out,h->bitsPerSample,outputComment);
    //printf("placing %d at index %d (%d)\n",
    //    Window[(Spot+SIZE)%SIZE2],Spot+SIZE,(Spot+SIZE)%SIZE2);
    //getchar();

    if (feof(in)) --Remaining;
       
    return amp;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $-0x1, 0x6991(%rip)     # 0x812c
jne 0x17ec
movl $0xa, 0x6981(%rip)      # 0x8128
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x17ea
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x24d6(%rip), %rcx      # 0x3ca0
callq 0x2ff0
movl %eax, %edx
movslq -0x1c(%rbp), %rcx
leaq 0x6984(%rip), %rax      # 0x8160
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x17ae
jmp 0x17ec
movl 0x693a(%rip), %eax      # 0x812c
addl $0x1, %eax
movl %eax, 0x6931(%rip)      # 0x812c
movl 0x692b(%rip), %eax      # 0x812c
movl $0x15, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x694d(%rip), %rax      # 0x8160
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x2471(%rip), %rcx      # 0x3ca0
callq 0x2ff0
movl %eax, -0x24(%rbp)
movl 0x68ef(%rip), %eax      # 0x812c
addl $0xa, %eax
movl $0x15, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl -0x24(%rbp), %edx
movslq %eax, %rcx
leaq 0x6909(%rip), %rax      # 0x8160
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rdi
callq 0x1130
cmpl $0x0, %eax
je 0x1877
movl 0x68ba(%rip), %eax      # 0x8128
addl $-0x1, %eax
movl %eax, 0x68b1(%rip)      # 0x8128
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/ADTStack_test.c
// Function: test_create
void test_create(void) {
	Stack stack = stack_create(NULL);
	stack_set_destroy_value(stack, NULL);

	TEST_ASSERT(stack != NULL);
	TEST_ASSERT(stack_size(stack) == 0);

	stack_destroy(stack);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x51b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x52b0
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1f0b(%rip), %rsi      # 0x62e1
movl $0x11, %edx
leaq 0x2022(%rip), %rcx      # 0x6404
leaq 0x1f08(%rip), %r8       # 0x62f1
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x43fa
callq 0x2e50
jmp 0x43fc
jmp 0x43fe
movq -0x8(%rbp), %rdi
callq 0x51e0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1ec8(%rip), %rsi      # 0x62e1
movl $0x12, %edx
leaq 0x1fdf(%rip), %rcx      # 0x6404
leaq 0x1ed3(%rip), %r8       # 0x62ff
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x443d
callq 0x2e50
jmp 0x443f
movq -0x8(%rbp), %rdi
callq 0x52e0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/ADTStack_test.c
// Function: test_insert
void test_insert(void) {
	Stack stack = stack_create(NULL);
	int N = 1000;
	int* array = malloc(N * sizeof(*array));					// Στο stack θα προσθέσουμε pointers προς τα στοιχεία αυτού του πίνακα

	// insert 1000 στοιχεία
	for (int i = 0; i < 1000; i++) {
		stack_insert_top(stack, &array[i]);
		TEST_ASSERT(stack_size(stack) == i+1);		// Το μέγεθος πρέπει να μεγαλώσει
		TEST_ASSERT(stack_top(stack) == &array[i]);	// Στην κορυφή είναι πάντα το στοιχείο που μόλις βάλαμε!
	}

	stack_destroy(stack);
	free(array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x51b0
movq %rax, -0x8(%rbp)
movl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2190
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3e8, -0x1c(%rbp)     # imm = 0x3E8
jge 0x4551
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x5250
movq -0x8(%rbp), %rdi
callq 0x51e0
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1e18(%rip), %rsi      # 0x62e1
movl $0x1f, %edx
leaq 0x1f2f(%rip), %rcx      # 0x6404
leaq 0x1e3a(%rip), %r8       # 0x6316
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x44ed
callq 0x2e50
jmp 0x44ef
jmp 0x44f1
movq -0x8(%rbp), %rdi
callq 0x5210
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1dc6(%rip), %rsi      # 0x62e1
movl $0x20, %edx
leaq 0x1edd(%rip), %rcx      # 0x6404
leaq 0x1e01(%rip), %r8       # 0x632f
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x453f
callq 0x2e50
jmp 0x4541
jmp 0x4543
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4484
movq -0x8(%rbp), %rdi
callq 0x52e0
movq -0x18(%rbp), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/ADTStack_test.c
// Function: test_remove
void test_remove(void) {
	Stack stack = stack_create(NULL);
	int N = 1000;
	int* array = malloc(N * sizeof(*array));

	// insert για προσθήκη δεδομένων, χωρίς ελέγχους (έχουμε ξεχωριστό test για το insert)
	for (int i = 0; i < 1000; i++)
		stack_insert_top(stack, &array[i]);

	// Διαδοχικά remove
	for (int i = 999; i >= 0; i--) {
		TEST_ASSERT(stack_top(stack) == &array[i]);
		stack_remove_top(stack);
		TEST_ASSERT(stack_size(stack) == i);
	}

	stack_destroy(stack);
	free(array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x51b0
movq %rax, -0x8(%rbp)
movl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2190
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3e8, -0x1c(%rbp)     # imm = 0x3E8
jge 0x45d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x5250
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x45a4
movl $0x3e7, -0x20(%rbp)     # imm = 0x3E7
cmpl $0x0, -0x20(%rbp)
jl 0x468d
jmp 0x45e3
movq -0x8(%rbp), %rdi
callq 0x5210
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1cd4(%rip), %rsi      # 0x62e1
movl $0x32, %edx
leaq 0x1deb(%rip), %rcx      # 0x6404
leaq 0x1d0f(%rip), %r8       # 0x632f
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x4631
callq 0x2e50
jmp 0x4633
movq -0x8(%rbp), %rdi
callq 0x5280
movq -0x8(%rbp), %rdi
callq 0x51e0
cmpl -0x20(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1c8a(%rip), %rsi      # 0x62e1
movl $0x34, %edx
leaq 0x1da1(%rip), %rcx      # 0x6404
leaq 0x1ce3(%rip), %r8       # 0x634d
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x467b
callq 0x2e50
jmp 0x467d
jmp 0x467f
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x45d7
movq -0x8(%rbp), %rdi
callq 0x52e0
movq -0x18(%rbp), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/genetic.c
// Function: rng_init
static void
rng_init(void *p, size_t len)
{
    FILE *f = fopen("/dev/urandom", "rb");
    if (!f)
        abort();
    if (!fread(p, 1, len, f))
        abort();
    fclose(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x19cb(%rip), %rdi      # 0x3082
leaq 0x19d1(%rip), %rsi      # 0x308f
callq 0x10b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x16d3
callq 0x1030
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x1050
cmpq $0x0, %rax
jne 0x16f4
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1060
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/genetic.c
// Function: gene_gen
static void
gene_gen(struct gene *g, uint64_t rng[4])
{
    uint64_t s = rand64(rng);
    uint64_t c = rand64(rng);
    g->s[0] = 10 + (s >>  0) % 10;
    g->s[1] = 10 + (s >> 24) % 10;
    g->s[2] = 10 + (s >> 48) % 10;
    g->c[0] = c | 1u;
    g->c[1] = (c >> 32) | 1u;
    g->flags = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f80
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f80
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
shrq $0x0, %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
addq $0xa, %rdx
movw %dx, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x18(%rbp), %rax
shrq $0x18, %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
addq $0xa, %rdx
movw %dx, %cx
movq -0x8(%rbp), %rax
movw %cx, 0xa(%rax)
movq -0x18(%rbp), %rax
shrq $0x30, %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
addq $0xa, %rdx
movw %dx, %cx
movq -0x8(%rbp), %rax
movw %cx, 0xc(%rax)
movq -0x20(%rbp), %rax
orq $0x1, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
shrq $0x20, %rax
orq $0x1, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/genetic.c
// Function: cmp
static int
cmp(const void *pa, const void *pb)
{
    double a = *(double *)pa;
    double b = *(double *)pb;
    if (a < b)
        return -1;
    if (b < a)
        return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1daf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1dcf
movsd -0x28(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1dc8
movl $0x1, -0x4(%rbp)
jmp 0x1dcf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/genetic.c
// Function: gene_cross
static void
gene_cross(struct gene *g,
           const struct gene *a,
           const struct gene *b,
           uint64_t rng[4])
{
    uint64_t r = rand64(rng);
    *g = *a;
    switch (r & 2) {
        case 0: g->c[0] = b->c[0]; /* FALLTHROUGH */
        case 1: g->s[1] = b->s[1]; /* FALLTHROUGH */
        case 2: g->c[1] = b->c[1]; /* FALLTHROUGH */
        case 3: g->s[2] = b->s[2];
    }
    g->flags = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1f80
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq -0x28(%rbp), %rax
andl $0x2, %eax
movq %rax, -0x30(%rbp)
subq $0x3, %rax
ja 0x1edc
movq -0x30(%rbp), %rax
leaq 0x1199(%rip), %rcx      # 0x3030
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movw 0xa(%rax), %cx
movq -0x8(%rbp), %rax
movw %cx, 0xa(%rax)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
movw 0xc(%rax), %cx
movq -0x8(%rbp), %rax
movw %cx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/genetic.c
// Function: undup
static void
undup(struct gene *pool, uint64_t rng[4])
{
    for (int i = 0; i < POOL; i++)
        for (int j = i + 1; j < POOL; j++)
            if (gene_same(pool + i, pool + j))
                gene_mutate(pool + j, rng);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x28, -0x14(%rbp)
jge 0x1f76
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x28, -0x18(%rbp)
jge 0x1f69
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x18(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x20c0
cmpl $0x0, %eax
je 0x1f5c
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2150
jmp 0x1f5e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1f16
jmp 0x1f6b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1f07
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/genetic.c
// Function: rand64
static uint64_t
rand64(uint64_t s[4])
{
    uint64_t x = s[1] * 5;
    uint64_t r = ((x << 7) | (x >> 57)) * 9;
    uint64_t t = s[1] << 17;
    s[2] ^= s[0];
    s[3] ^= s[1];
    s[1] ^= s[2];
    s[0] ^= s[3];
    s[2] ^= t;
    s[3] = (s[3] << 45) | (s[3] >> 19);
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
imulq $0x5, 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x7, %rax
movq -0x10(%rbp), %rcx
shrq $0x39, %rcx
orq %rcx, %rax
imulq $0x9, %rax, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
shlq $0x11, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
xorq (%rax), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
xorq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
shlq $0x2d, %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x13, %rax
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/genetic.c
// Function: hash
static uint32_t
hash(const struct gene *g, uint32_t x)
{
    x ^= x >> g->s[0];
    x *= g->c[0];
    x ^= x >> g->s[1];
    x *= g->c[1];
    x ^= x >> g->s[2];
    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movswl 0x8(%rcx), %ecx
shrl %cl, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movswl 0xa(%rcx), %ecx
shrl %cl, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movswl 0xc(%rcx), %ecx
shrl %cl, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/genetic.c
// Function: gene_same
static int
gene_same(const struct gene *a, const struct gene *b)
{
    return a->s[0] == b->s[0] &&
           a->s[1] == b->s[1] &&
           a->s[2] == b->s[2] &&
           a->c[0] == b->c[0] &&
           a->c[1] == b->c[1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movswl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movswl 0x8(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
jne 0x2140
movq -0x8(%rbp), %rax
movswl 0xa(%rax), %ecx
movq -0x10(%rbp), %rax
movswl 0xa(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
jne 0x2140
movq -0x8(%rbp), %rax
movswl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movswl 0xc(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
jne 0x2140
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x10(%rdx), %ecx
movb %al, -0x11(%rbp)
jne 0x2140
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/genetic.c
// Function: gene_mutate
static void
gene_mutate(struct gene *g, uint64_t rng[4])
{
    uint64_t r = rand64(rng);
    int s = r % 5;
    r >>= 3;
    switch (s) {
        case 0:
            g->s[0] += small(r);
            break;
        case 1:
            g->s[1] += small(r);
            break;
        case 2:
            g->s[2] += small(r);
            break;
        case 3:
            g->c[0] += (int)(r & 0xffff) - 32768;
            break;
        case 4:
            g->c[1] += (int)(r & 0xffff) - 32768;
            break;
    }
    g->flags = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
mulq %rcx
movq -0x30(%rbp), %rax
shrq $0x2, %rdx
movl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x4, %rax
ja 0x2250
movq -0x28(%rbp), %rax
leaq 0xe84(%rip), %rcx       # 0x3040
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
callq 0x2270
movl %eax, %edx
movq -0x8(%rbp), %rax
movswl 0x8(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x8(%rax)
jmp 0x2250
movq -0x18(%rbp), %rdi
callq 0x2270
movl %eax, %edx
movq -0x8(%rbp), %rax
movswl 0xa(%rax), %ecx
addl %edx, %ecx
movw %cx, 0xa(%rax)
jmp 0x2250
movq -0x18(%rbp), %rdi
callq 0x2270
movl %eax, %edx
movq -0x8(%rbp), %rax
movswl 0xc(%rax), %ecx
addl %edx, %ecx
movw %cx, 0xc(%rax)
jmp 0x2250
movq -0x18(%rbp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
movl %eax, %ecx
subl $0x8000, %ecx           # imm = 0x8000
movq -0x8(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0x2250
movq -0x18(%rbp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
movl %eax, %ecx
subl $0x8000, %ecx           # imm = 0x8000
movq -0x8(%rbp), %rax
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_is_eq
struct value*
builtin_is_eq(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("eq?", args, 2);

    struct value* a = CAR(args);
    struct value* b = CADR(args);

    return value_is_eq(a, b) ? vm_make_boolean(vm, true) : vm_make_boolean(vm, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x65c0
cmpq $0x2, %rax
je 0x2341
movq 0xbcda(%rip), %rax      # 0xdfe0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x65c0
movq -0x28(%rbp), %rdi
movq %rax, %r8
leaq 0x7ee0(%rip), %rsi      # 0xa204
leaq 0x7d0a(%rip), %rdx      # 0xa035
movl $0x2, %ecx
movb $0x0, %al
callq 0x1200
movl $0x1, %edi
callq 0x11a0
movq -0x10(%rbp), %rdi
callq 0x6710
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6620
movq %rax, %rdi
callq 0x6710
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x87e0
testb $0x1, %al
jne 0x2376
jmp 0x238a
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8e90
movq %rax, -0x30(%rbp)
jmp 0x2399
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x8e90
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_is_eqv
struct value*
builtin_is_eqv(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("eqv?", args, 2);

    struct value* a = CAR(args);
    struct value* b = CADR(args);

    return value_is_eqv(a, b) ? vm_make_boolean(vm, true) : vm_make_boolean(vm, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x65c0
cmpq $0x2, %rax
je 0x2411
movq 0xbc0a(%rip), %rax      # 0xdfe0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x65c0
movq -0x28(%rbp), %rdi
movq %rax, %r8
leaq 0x7e10(%rip), %rsi      # 0xa204
leaq 0x7c3e(%rip), %rdx      # 0xa039
movl $0x2, %ecx
movb $0x0, %al
callq 0x1200
movl $0x1, %edi
callq 0x11a0
movq -0x10(%rbp), %rdi
callq 0x6710
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6620
movq %rax, %rdi
callq 0x6710
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8810
testb $0x1, %al
jne 0x2446
jmp 0x245a
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8e90
movq %rax, -0x30(%rbp)
jmp 0x2469
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x8e90
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_is_equal
struct value*
builtin_is_equal(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("equal?", args, 2);

    struct value* a = CAR(args);
    struct value* b = CADR(args);

    return value_is_equal(a, b) ? vm_make_boolean(vm, true) : vm_make_boolean(vm, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x65c0
cmpq $0x2, %rax
je 0x24e1
movq 0xbb3a(%rip), %rax      # 0xdfe0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x65c0
movq -0x28(%rbp), %rdi
movq %rax, %r8
leaq 0x7d40(%rip), %rsi      # 0xa204
leaq 0x7b73(%rip), %rdx      # 0xa03e
movl $0x2, %ecx
movb $0x0, %al
callq 0x1200
movl $0x1, %edi
callq 0x11a0
movq -0x10(%rbp), %rdi
callq 0x6710
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6620
movq %rax, %rdi
callq 0x6710
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8840
testb $0x1, %al
jne 0x2516
jmp 0x252a
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8e90
movq %rax, -0x30(%rbp)
jmp 0x2539
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x8e90
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)