LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/serge-404[P]CPM32/cpm.c
// Function: frameup_dpb_alloc
void frameup_dpb_alloc( void)
{
    DWORD spc, bps, free, total;
    DWORD *alloc = (DWORD *)(mem + DMY_ALLOC);
    byte sft;
    int i;

    GetDiskFreeSpace( NULL, &spc, &bps, &free, &total);
    spc *= bps;
    spc >>= 9; sft = 2;
    /* 2008.12 for large disk space (> 2TBytes) */
    while ( spc && (spc & 1) == 0) { spc >>= 1; sft++; }
    free *= spc;
    while ( free > MAXBLK) { free >>= 1; sft++; }
    mem[ DMY_DPB_SFT] = sft;
    *(word *)(mem + DMY_DPB_MSK) = (word)((1 << sft) - 1);

    i = 0;
    while ( free >= 32) {
        free -= 32; alloc[ i++] = 0;
    }
    alloc[ i++] = ~0 << free;
    while ( i < MAXBLK/32) alloc[ i++] = ~0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0xa680(%rip), %r15      # 0x131f8
leaq 0x18(%rsp), %rbx
leaq 0x10(%rsp), %r14
movq %rsp, %rcx
leaq 0x8(%rsp), %r8
xorl %edi, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x80a0
movq (%rbx), %rax
imulq (%r14), %rax
shrq $0x9, %rax
pushq $0x2
popq %rcx
testq %rax, %rax
je 0x8bb8
movl %eax, %edx
andl $0x1, %edx
jne 0x8bb8
shrq %rax
incl %ecx
jmp 0x8ba5
imulq (%rsp), %rax
cmpq $0x401, %rax            # imm = 0x401
jb 0x8bcc
shrq %rax
incl %ecx
jmp 0x8bbd
movq 0xa625(%rip), %rdx      # 0x131f8
pushq $-0x1
popq %rsi
movl %esi, %edi
shll %cl, %edi
movb %cl, 0xff12(%rdx)
notl %edi
movw %di, 0xff13(%rdx)
xorl %edx, %edx
cmpq $0x20, %rax
jb 0x8c03
addq $-0x20, %rax
andq $0x0, 0xff20(%r15,%rdx,8)
incq %rdx
jmp 0x8beb
movl %eax, %ecx
shll %cl, %esi
movslq %esi, %rsi
movl %edx, %edi
leaq -0x1(%rdx), %rax
pushq $-0x1
popq %rcx
movq %rsi, 0xff20(%r15,%rdi,8)
incq %rdx
incq %rax
movq %rdx, %rdi
movq %rcx, %rsi
cmpq $0x1f, %rax
jb 0x8c13
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/serge-404[P]CPM32/cpm.c
// Function: cpm_gettime
byte cpm_gettime( byte *buf, time_t t)
{
    int d;
    static time_t time780101;

    if ( time780101 == 0) {
 	struct tm tm;
	memset( &tm, 0, sizeof tm);
	tm.tm_year = 78;
	tm.tm_mon =   0;
	tm.tm_mday =  1;
	time780101 = mktime( &tm);
    }

    t -= time780101;
    d = t % 60; t /= 60;
    buf[ 4] = (byte)((d % 10) + ((d / 10) << 4));
    d = t % 60; t /= 60;
    buf[ 3] = (byte)((d % 10) + ((d / 10) << 4));
    d = t % 24; t /= 24;
    buf[ 2] = (byte)((d % 10) + ((d / 10) << 4));
    d = t + 1;
    buf[ 0] = (byte)d;
    buf[ 1] = (byte)(d >> 8);

    return buf[ 4];
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10cccd(%rip), %rax    # 0x115918
testq %rax, %rax
jne 0x8c80
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x10(%rdi)
andq $0x0, 0x30(%rdi)
movaps %xmm0, (%rdi)
movaps %xmm0, 0x20(%rdi)
movl $0x4e, 0x14(%rdi)
movl $0x1, 0xc(%rdi)
callq 0x22c0
movq %rax, 0x10cc98(%rip)    # 0x115918
subq %rax, %r14
pushq $0x3c
popq %r8
movq %r14, %rax
cqto
idivq %r8
movq %rax, %rsi
movsbl %dl, %eax
movb $0xa, %dil
idivb %dil
movl %eax, %ecx
movsbl %ah, %eax
shlb $0x4, %cl
addb %al, %cl
movb %cl, 0x4(%rbx)
movq %rsi, %rax
cqto
idivq %r8
movq %rdx, %rsi
movl $0xe10, %r8d            # imm = 0xE10
movq %r14, %rax
cqto
idivq %r8
movq %rax, %rdx
movsbl %sil, %eax
idivb %dil
movsbl %ah, %esi
shlb $0x4, %al
addb %sil, %al
movb %al, 0x3(%rbx)
pushq $0x18
popq %rsi
movq %rdx, %rax
cqto
idivq %rsi
movq %rdx, %rsi
movl $0x15180, %r8d          # imm = 0x15180
movq %r14, %rax
cqto
idivq %r8
movq %rax, %rdx
movsbl %sil, %eax
idivb %dil
movsbl %ah, %esi
shlb $0x4, %al
addb %sil, %al
movb %al, 0x2(%rbx)
incl %edx
movb %dl, (%rbx)
movb %dh, 0x1(%rbx)
movl %ecx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/serge-404[P]CPM32/cpm.c
// Function: cpm_disk_reset
byte cpm_disk_reset( void)
{
    HANDLE hFndFile;
    WIN32_FIND_DATA aFindData;

    cpm_disk_no = 0;
    cpm_dma_addr = 0x80;

    sprintf( filename, "%s|*.*", cpm_drive[ cpm_disk_no]);
    hFndFile = FindFirstFile( filename, &aFindData);
    if ( hFndFile == INVALID_HANDLE_VALUE) return 0;
    FindClose( hFndFile);
    return 0xff;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movb $0x0, 0xa4e5(%rip)      # 0x13210
movw $0x80, 0xa4de(%rip)     # 0x13212
movq 0x10a705(%rip), %rdx    # 0x113440
leaq 0x10bd9e(%rip), %r14    # 0x114ae0
leaq 0x715c(%rip), %rsi      # 0xfea5
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2390
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x7d9a
testq %rax, %rax
je 0x8d71
movq %rax, %rdi
callq 0x807b
movb $-0x1, %bl
movl %ebx, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/serge-404[P]CPM32/cpm.c
// Function: cpm_lst_out
void cpm_lst_out( byte c)	/* LST: out */
{
    static int err;

    if ( lstfp == NULL && !err) {
	char *dev = getenv( "CPMLST");
	err = ( lstfp = fopen( dev ? dev : "PRN:", "wb")) == NULL;
    }
    if ( lstfp) putc( c, lstfp);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movq 0x10cba0(%rip), %rsi    # 0x115928
testq %rsi, %rsi
jne 0x8dd4
cmpl $0x0, 0x10cb8c(%rip)    # 0x115920
jne 0x8dd4
leaq 0x710f(%rip), %rdi      # 0xfeac
callq 0x2040
testq %rax, %rax
leaq 0x7107(%rip), %rdi      # 0xfeb3
cmovneq %rax, %rdi
leaq 0x7101(%rip), %rsi      # 0xfeb8
callq 0x2340
movq %rax, %rsi
movq %rax, 0x10cb62(%rip)    # 0x115928
xorl %eax, %eax
testq %rsi, %rsi
sete %al
movl %eax, 0x10cb4c(%rip)    # 0x115920
testq %rsi, %rsi
je 0x8de2
movzbl %bl, %edi
popq %rbx
jmp 0x21e0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/serge-404[P]CPM32/cpm.c
// Function: cpm_rdr_in
byte cpm_rdr_in( void)		/* RDR: in */
{
    static int err;
    char *dev;
    int c, ct = 16;

    if ( rdrfp == NULL && !err) {
	if (( dev = getenv( "CPMRDR")) != NULL) {
	    err = ( rdrfp = fopen( dev, "r+b")) == NULL;
	} else if ( punfp) {
	    rdrfp = punfp;
	} else {
	    dev = getenv( "CPMAUX");
	    err = ( rdrfp = fopen( dev ? dev : "AUX:", "r+b")) == NULL;
	}
    }
    if ( rdrfp && ( c = getc( rdrfp)) != EOF) return (byte)c;
    if ( --ct == 0) exit( 0);
    return '\x1a';
}

// Assembly:
pushq %rax
movq 0x10cb4c(%rip), %rdi    # 0x115938
testq %rdi, %rdi
jne 0x8e32
cmpl $0x0, 0x10cb38(%rip)    # 0x115930
jne 0x8e32
leaq 0x70ba(%rip), %rdi      # 0xfebb
callq 0x2040
testq %rax, %rax
je 0x8e4d
leaq 0x7021(%rip), %rsi      # 0xfe33
movq %rax, %rdi
callq 0x2340
movq %rax, %rdi
movq %rax, 0x10cb14(%rip)    # 0x115938
xorl %eax, %eax
testq %rdi, %rdi
sete %al
movl %eax, 0x10cafe(%rip)    # 0x115930
testq %rdi, %rdi
je 0x8e49
callq 0x23c0
movl %eax, %ecx
cmpl $-0x1, %eax
pushq $0x1a
popq %rax
cmovnel %ecx, %eax
jmp 0x8e4b
movb $0x1a, %al
popq %rcx
retq
movq 0x10caec(%rip), %rdi    # 0x115940
testq %rdi, %rdi
je 0x8e62
movq %rdi, 0x10cad8(%rip)    # 0x115938
jmp 0x8e37
leaq 0x7059(%rip), %rdi      # 0xfec2
callq 0x2040
movq %rax, %rcx
testq %rax, %rax
leaq 0x704e(%rip), %rax      # 0xfec9
cmovneq %rcx, %rax
jmp 0x8e0b
// File: /workspace/github_c_makefile_star2_O2/serge-404[P]CPM32/cpm.c
// Function: cpm_pun_out
void cpm_pun_out( byte c)	/* PUN: out */
{
    static int err;
    char *dev;

    if ( punfp == NULL && !err) {
	if (( dev = getenv( "CPMPUN")) != NULL) {
	    err = ( punfp = fopen( dev, "r+b")) == NULL;
	} else if ( rdrfp) {
	    punfp = rdrfp;
	} else {
	    dev = getenv( "CPMAUX");
	    err = ( punfp = fopen( dev ? dev : "AUX:", "r+b")) == NULL;
	}
    }
    if ( punfp) putc( c, punfp);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movq 0x10cab5(%rip), %rsi    # 0x115940
testq %rsi, %rsi
jne 0x8ed1
cmpl $0x0, 0x10cab1(%rip)    # 0x115948
jne 0x8ed1
leaq 0x702e(%rip), %rdi      # 0xfece
callq 0x2040
testq %rax, %rax
je 0x8ee1
leaq 0x6f82(%rip), %rsi      # 0xfe33
movq %rax, %rdi
callq 0x2340
movq %rax, %rsi
movq %rax, 0x10ca7d(%rip)    # 0x115940
xorl %eax, %eax
testq %rsi, %rsi
sete %al
movl %eax, 0x10ca77(%rip)    # 0x115948
testq %rsi, %rsi
je 0x8edf
movzbl %bl, %edi
popq %rbx
jmp 0x21e0
popq %rbx
retq
movq 0x10ca50(%rip), %rsi    # 0x115938
testq %rsi, %rsi
je 0x8ef6
movq %rsi, 0x10ca4c(%rip)    # 0x115940
jmp 0x8ed6
leaq 0x6fc5(%rip), %rdi      # 0xfec2
callq 0x2040
movq %rax, %rcx
testq %rax, %rax
leaq 0x6fba(%rip), %rax      # 0xfec9
cmovneq %rcx, %rax
jmp 0x8eaa
// File: /workspace/github_c_makefile_star2_O2/serge-404[P]CPM32/cpm.c
// Function: cpull
int cpull()					/* FIFO imitation */
{
        int res=xgch;
        xgch=xgch2;
        xgch2=xgch3;
        xgch3=CON_BUF_EMPTY;
        return res;
}

// Assembly:
movl 0xa2d3(%rip), %eax      # 0x13234
movl 0xa2d1(%rip), %ecx      # 0x13238
movl %ecx, 0xa2c7(%rip)      # 0x13234
movl 0xa2c9(%rip), %ecx      # 0x1323c
movl %ecx, 0xa2bf(%rip)      # 0x13238
orl $-0x1, 0xa2bc(%rip)     # 0x1323c
retq
// File: /workspace/github_c_makefile_star2_O2/serge-404[P]CPM32/cpm.c
// Function: getCursorPosition
void getCursorPosition(int *row, int *col) {
	fflush(0);
    printf("\x1b[6n");
    char buff[128];
    int indx = 0;
    for(;;) {
        int cc = getchar();
        buff[indx] = (char)cc;
        indx++;
        if(cc == 'R') {
            buff[indx + 1] = '\0';
            break;
        }
    }    
    sscanf(buff, "\x1b[%d;%dR", row, col);
    fseek(stdin, 0, SEEK_END);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
callq 0x2290
leaq 0x6f34(%rip), %rdi      # 0xfed5
xorl %eax, %eax
callq 0x2100
pushq $0x1
popq %r15
callq 0x21f0
movb %al, -0x1(%rsp,%r15)
incq %r15
cmpl $0x52, %eax
jne 0x8fac
movl %r15d, %eax
movb $0x0, (%rsp,%rax)
leaq 0x6f0e(%rip), %rsi      # 0xfeda
movq %rsp, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x22a0
movq 0x9ff5(%rip), %rax      # 0x12fd8
movq (%rax), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x22d0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %ebp
xorl %r12d, %r12d
leaq 0x10(%rsp), %r14
movl $0x5413, %esi           # imm = 0x5413
xorl %edi, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2160
movzwl 0x2(%r14), %r13d
movzwl (%r14), %r14d
leaq 0x8(%rsp), %rdi
leaq 0xc(%rsp), %r15
movq %r15, %rsi
callq 0x8f81
addl (%r15), %ebp
leaq 0x8(%rsp), %rax
addl (%rax), %ebx
leal -0x1(%r13), %eax
testl %ebp, %ebp
movl $0x0, %ecx
cmovgl %ebp, %ecx
cmpl %r13d, %ebp
cmovgel %eax, %ecx
leal -0x1(%r14), %eax
testl %ebx, %ebx
cmovgl %ebx, %r12d
cmpl %r14d, %ebx
cmovgel %eax, %r12d
movswl %r12w, %edi
movswl %cx, %esi
callq 0x8f49
movq 0x9f4c(%rip), %rax      # 0x12fd0
movq (%rax), %rdi
callq 0x2290
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/serge-404[P]CPM32/cpm.c
// Function: toggleInvertion
void toggleInvertion(void) {
	if (inverted) {
		setTextNoInverted();
	    inverted=FALSE;
	}
	else {
		setTextInverted();
	    inverted=TRUE;
	}
}

// Assembly:
pushq %rax
cmpl $0x0, 0x10a0d5(%rip)    # 0x113310
je 0x9246
callq 0xb137
xorl %eax, %eax
jmp 0x924e
callq 0xb145
pushq $0x1
popq %rax
movl %eax, 0x10a0bc(%rip)    # 0x113310
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x24cc
leaq 0x2(%rbx), %r14
movzbl (%rbx), %esi
movq 0x9bb2(%rip), %rax      # 0x12fd8
movq (%rax), %rdx
movq %r14, %rdi
callq 0x21d0
testq %rax, %rax
jne 0x944e
callq 0x2508
decl 0x9def(%rip)            # 0x13230
je 0x948f
movb $0x0, 0x2(%r14)
movw $0xa1a, (%r14)          # imm = 0xA1A
callq 0x2508
movq %r14, %rdi
callq 0x20e0
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
subl %ecx, %eax
cltq
movb $0xd, 0x2(%rbx,%rax)
movb %al, 0x1(%rbx)
cmpl $0x0, 0x10c4db(%rip)    # 0x115950
je 0x9485
cmpl $0x0, 0x10c4d6(%rip)    # 0x115954
je 0x9485
callq 0x9195
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x926d
xorl %edi, %edi
callq 0x23a0
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]libcperciva/tests/warnp/main.c
// Function: main
int
main(int argc, char * argv[])
{
	const char * extra_message;
	int desired_test;

	WARNP_INIT;

	/* Parse command-line argument. */
	if (argc != 3) {
		fprintf(stderr, "usage: test_warnp STRING NUM\n");
		exit(1);
	}
	extra_message = argv[1];
	if (PARSENUM(&desired_test, argv[2], 1, 2)) {
		warnp("parsenum");
		goto err0;
	}

	/* Run the desired test. */
	switch (desired_test) {
	case 1:
		check_stderr_syslog(extra_message);
		break;
	case 2:
		if (check_multithread())
			goto err0;
		break;
	default:
		warn0("invalid test number");
		goto err0;
	}

	/* Switch to syslog again. */
	warnp_syslog(1);
	warn0("syslog again");

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movl %edi, %ebx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x128c
callq 0x1518
cmpl $0x3, %ebx
jne 0x12c5
movq 0x8(%r15), %r14
callq 0x1070
andl $0x0, (%rax)
movq 0x10(%r15), %r12
testq %r12, %r12
jne 0x12e3
leaq 0xd8b(%rip), %rdi       # 0x2038
leaq 0xd8e(%rip), %rsi       # 0x2042
leaq 0xd9d(%rip), %rcx       # 0x2058
movl $0xa7, %edx
callq 0x1090
movq 0x2d2c(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd2e(%rip), %rdi       # 0x2004
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x1130
jmp 0x1326
movq %rax, %rbx
movq %rsp, %r15
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1040
movq (%r15), %rdx
pushq $0x16
popq %rcx
cmpq %r12, %rdx
je 0x1313
cmpb $0x0, (%rdx)
jne 0x1313
leaq -0x3(%rax), %rcx
cmpq $-0x3, %rcx
ja 0x132e
pushq $0x22
popq %rcx
movl %ecx, (%rbx)
leaq 0xd06(%rip), %rdi       # 0x2022
xorl %eax, %eax
callq 0x1595
andl $0x0, (%rbx)
pushq $0x1
popq %rdi
callq 0x1120
cmpl $0x0, (%rbx)
jne 0x1315
cmpq $0x1, %rax
jne 0x1389
movq %r14, %rdi
callq 0x1404
pushq $0x1
popq %rdi
callq 0x1883
movq %r14, %rdi
callq 0x1404
xorl %edi, %edi
callq 0x1883
leaq 0xd3e(%rip), %rdi       # 0x209d
xorl %eax, %eax
callq 0x1724
andl $0x0, (%rbx)
pushq $0x1
popq %rdi
callq 0x1883
leaq 0xcb3(%rip), %rdi       # 0x202b
xorl %eax, %eax
callq 0x1724
andl $0x0, (%rbx)
xorl %edi, %edi
callq 0x1120
leaq 0x1c(%rsp), %r12
xorl %ebp, %ebp
leaq 0x137(%rip), %r13       # 0x14ce
leaq 0xd34(%rip), %r14       # 0x20d2
cmpq $0x3, %rbp
je 0x13c9
movl %ebp, (%r12)
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
callq 0x10f0
incq %rbp
addq $0x8, %r15
addq $0x4, %r12
testl %eax, %eax
je 0x139e
jmp 0x13eb
xorl %r15d, %r15d
leaq 0xd12(%rip), %r14       # 0x20e5
cmpq $0x3, %r15
je 0x1369
movq (%rsp,%r15,8), %rdi
xorl %esi, %esi
callq 0x1140
incq %r15
testl %eax, %eax
je 0x13d3
movl %eax, %edi
callq 0x1160
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x1724
jmp 0x1323
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdi, %rsi
leaq 0xc91(%rip), %rdi       # 0x20ac
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x1724
callq 0x1070
movq %rax, %rbx
andl $0x0, (%rax)
xorl %edi, %edi
xorl %eax, %eax
callq 0x1724
pushq $0x2
popq %rbp
movl %ebp, (%rbx)
xorl %edi, %edi
xorl %eax, %eax
callq 0x1595
andl $0x0, (%rbx)
xorl %edi, %edi
xorl %eax, %eax
callq 0x1724
andl $0x0, (%rbx)
leaq 0xc66(%rip), %r14       # 0x20c3
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x1724
movl %ebp, (%rbx)
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1595
andl $0x0, (%rbx)
movq %rsp, %rax
pushq $0x1
popq %rcx
cmpq $0x1e, %r15
je 0x14ac
leal 0x61(%r15), %edx
imulq $0xa, %r15, %rsi
movb %dl, (%rsp,%rsi)
movq %rcx, %rdx
cmpq $0xa, %rdx
je 0x14a3
movb $0x5f, (%rax,%rdx)
incq %rdx
jmp 0x1494
incq %r15
addq $0xa, %rax
jmp 0x1480
movq %rsp, %rdi
movb $0x0, 0x12c(%rdi)
xorl %eax, %eax
callq 0x1724
andl $0x0, (%rbx)
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %ebx
callq 0x1070
movq %rax, %r14
leaq 0xc10(%rip), %r15       # 0x20f6
xorl %ebp, %ebp
cmpl $0xa, %ebp
je 0x150a
movl $0x2, (%r14)
movq %r15, %rdi
movl %ebx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1595
andl $0x0, (%r14)
incl %ebp
jmp 0x14e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
testl %edi, %edi
je 0x1f1d1
retq
pushq %rax
movl 0x8(%rsi), %eax
movq (%rsi), %rdx
leaq 0xe31(%rip), %rdi       # 0x20010
movl %eax, %esi
xorl %eax, %eax
callq 0x1f070
pushq $0x1
popq %rdi
callq 0x1f0c0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rbx
cmpl $0x2, %edi
jne 0x1f2c0
movq 0x8(%rsi), %rdi
leaq 0xe10(%rip), %rsi       # 0x2001f
callq 0x1f0b0
testq %rax, %rax
je 0x1f2c0
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1f0a0
movq %r14, %rdi
callq 0x1f080
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1f0a0
leal 0x1(%r12), %eax
movslq %eax, %rdi
callq 0x1f090
movq %rax, %r15
movslq %r12d, %r12
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x1f040
cmpq %r12, %rax
jb 0x1f2c0
movb $0x0, (%r15,%r12)
movq %r14, %rdi
callq 0x1f060
callq 0x1f050
movq %rax, %rbx
leaq -0xbd(%rip), %rdi       # 0x1f1cc
movq %r15, %rsi
xorl %edx, %edx
callq 0x1f2d0
callq 0x1f050
subq %rbx, %rax
cvtsi2sd %rax, %xmm0
divsd 0xd60(%rip), %xmm0      # 0x20008
leaq 0xd73(%rip), %rdi       # 0x20022
movb $0x1, %al
callq 0x1f070
movq %r15, %rdi
callq 0x1f030
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
andq $0x0, 0x10(%rsp)
cmpl $0x2, %edi
jl 0x121c
movq 0x8(%rsi), %rdi
callq 0x1090
movl %eax, 0x2e54(%rip)      # 0x4070
leaq -0x67(%rip), %rdx       # 0x11bc
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1070
xorl %edi, %edi
callq 0x1050
addq $0x2, %rax
movq %rax, 0x8(%rsp)
leaq 0x2e38(%rip), %rdi      # 0x4080
callq 0x10b0
cmpl $0x0, 0x2e84(%rip)      # 0x40d8
jne 0x129c
leaq 0x2e4b(%rip), %rbx      # 0x40a8
leaq 0x2e1c(%rip), %r14      # 0x4080
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1080
cmpl $0x6e, %eax
je 0x1287
cmpl $0x0, 0x2e55(%rip)      # 0x40d8
je 0x1269
jmp 0x129c
leaq 0xd76(%rip), %rdi       # 0x2004
callq 0x1030
cmpl $0x0, 0x2e3e(%rip)      # 0x40d8
je 0x12a8
leaq 0xd77(%rip), %rdi       # 0x201a
callq 0x1030
leaq 0x2dd1(%rip), %rdi      # 0x4080
callq 0x1060
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq $0x3ffffffe, 0x18(%rsp) # imm = 0x3FFFFFFE
cmpl $0x1, %edi
jle 0x123a
movl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
cmpl $0x2, %edi
je 0x11fb
movq 0x10(%rbx), %rdi
leaq 0xe4b(%rip), %rsi       # 0x2022
leaq 0x28(%rsp), %rdx
callq 0x10a0
testq %rax, %rax
je 0x1257
cmpb $0x0, (%rax)
jne 0x1257
leaq 0x28(%rsp), %rdi
callq 0x1050
movq %rax, (%rsp)
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x1060
testl %eax, %eax
js 0x122c
movl %eax, %ebx
movq %rsp, %rsi
movl %eax, %edi
callq 0x1080
testl %eax, %eax
js 0x122c
movl %ebx, %edi
callq 0x1030
xorl %eax, %eax
jmp 0x1276
leaq 0xe10(%rip), %rdi       # 0x2043
callq 0x1070
jmp 0x1273
movq 0x2db7(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0xdb6(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1040
jmp 0x1273
movq 0x2d9a(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xdcc(%rip), %rdi       # 0x2034
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0x1090
pushq $-0x1
popq %rax
addq $0x60, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x2e8a(%rip), %rdi      # 0x4088
callq 0x10b0
movl %eax, %edi
callq 0x1070
leaq 0xe2(%rip), %rsi        # 0x12f3
pushq $0xe
popq %rdi
callq 0x1080
callq 0x1392
movsd %xmm0, -0x20(%rbp)
callq 0x1392
movsd %xmm0, -0x18(%rbp)
leaq 0xe17(%rip), %rbx       # 0x204b
leaq 0xe5d(%rip), %r14       # 0x2098
callq 0x1392
movapd %xmm0, %xmm1
subsd -0x20(%rbp), %xmm1
ucomisd 0xdb7(%rip), %xmm1      # 0x2008
ja 0x12ae
movsd %xmm0, -0x28(%rbp)
subsd -0x18(%rbp), %xmm0
movsd 0xdab(%rip), %xmm1      # 0x2010
ucomisd %xmm0, %xmm1
jbe 0x12d6
movl 0x2e2b(%rip), %esi      # 0x409c
movq %rbx, %rdi
movb $0x1, %al
callq 0x1040
movb $0x0, 0x2e1e(%rip)      # 0x40a0
xorl %edi, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x10c0
testl %eax, %eax
jns 0x1299
jmp 0x12c5
callq 0x1090
cmpb $0x0, 0x2e00(%rip)      # 0x40a0
je 0x1294
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x123b
leaq 0x2dd3(%rip), %rdi      # 0x4088
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xd90(%rip), %rsi       # 0x205c
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x10a0
leaq 0xd43(%rip), %rdi       # 0x2020
leaq 0xd4c(%rip), %rsi       # 0x2030
leaq 0xd55(%rip), %rcx       # 0x2040
pushq $0x2a
popq %rdx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movb 0x2da1(%rip), %al       # 0x40a0
cmpb $0x1, %al
je 0x133a
incl 0x2d93(%rip)            # 0x409c
leaq 0x2d78(%rip), %rdi      # 0x4088
xorl %esi, %esi
callq 0x10d0
testl %eax, %eax
js 0x1357
cmpl $0x1, %eax
je 0x1368
leaq 0x2d61(%rip), %rdi      # 0x4088
callq 0x1030
movb $0x1, 0x2d6d(%rip)      # 0x40a0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xd25(%rip), %rdi       # 0x2066
leaq 0xce8(%rip), %rsi       # 0x2030
leaq 0xd22(%rip), %rcx       # 0x2071
pushq $0x18
popq %rdx
callq 0x1060
leaq 0xd28(%rip), %rsi       # 0x2086
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x10a0
leaq 0x2d19(%rip), %rbx      # 0x4088
movq %rbx, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x10e0
leaq 0xd08(%rip), %rsi       # 0x208d
pushq $0x1
popq %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
xorl %edi, %edi
callq 0x41e4
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x4214
xorl %edi, %edi
testq %rbx, %rbx
setne %dil
leaq 0x1882(%rip), %rsi      # 0x5318
leaq 0x1999(%rip), %rcx      # 0x5436
leaq 0x1884(%rip), %r8       # 0x5328
pushq $0x11
popq %rdx
xorl %eax, %eax
callq 0x239c
testl %eax, %eax
je 0x3aee
movq %rbx, %rdi
callq 0x41e9
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x184f(%rip), %rsi      # 0x5318
leaq 0x1966(%rip), %rcx      # 0x5436
leaq 0x185f(%rip), %r8       # 0x5336
pushq $0x12
popq %rdx
xorl %eax, %eax
callq 0x239c
testl %eax, %eax
je 0x3aee
movq %rbx, %rdi
popq %rbx
jmp 0x4219
callq 0x2bc0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x41e4
movq %rax, %rbx
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21b0
movq %rax, %rbp
pushq $0x1
popq %r14
leaq 0x17f8(%rip), %r15      # 0x5318
leaq 0x190f(%rip), %r12      # 0x5436
pushq $0x20
popq %r13
movq %rax, (%rsp)
cmpq $0x3e9, %r14            # imm = 0x3E9
je 0x3ba9
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x4203
movq %rbx, %rdi
callq 0x41e9
movl %eax, %eax
xorl %edi, %edi
cmpq %rax, %r14
sete %dil
movq %r15, %rsi
pushq $0x1f
popq %rdx
movq %r12, %rcx
leaq 0x17e7(%rip), %r8       # 0x534d
xorl %eax, %eax
callq 0x239c
testl %eax, %eax
je 0x3ba4
movq %rbx, %rdi
callq 0x41ee
xorl %edi, %edi
cmpq %rax, %rbp
sete %dil
movq %r15, %rsi
movl %r13d, %edx
movq %r12, %rcx
leaq 0x17d4(%rip), %r8       # 0x5366
xorl %eax, %eax
callq 0x239c
incq %r14
addq $0x4, %rbp
testl %eax, %eax
jne 0x3b2f
callq 0x2bc0
movq %rbx, %rdi
callq 0x4219
movq (%rsp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x41e4
movq %rax, %rbx
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21b0
movq %rax, %r14
cmpq $0xfa0, %r15            # imm = 0xFA0
je 0x3c08
leaq (%r14,%r15), %rsi
movq %rbx, %rdi
callq 0x4203
addq $0x4, %r15
jmp 0x3bed
movl $0x3e7, %r13d           # imm = 0x3E7
leaq 0x1703(%rip), %r15      # 0x5318
leaq 0x181a(%rip), %r12      # 0x5436
pushq $0x34
popq %rbp
testl %r13d, %r13d
js 0x3c92
movq %rbx, %rdi
callq 0x41ee
movl %r13d, %ecx
leaq (%r14,%rcx,4), %rcx
xorl %edi, %edi
cmpq %rcx, %rax
sete %dil
movq %r15, %rsi
pushq $0x32
popq %rdx
movq %r12, %rcx
leaq 0x171a(%rip), %r8       # 0x5366
xorl %eax, %eax
callq 0x239c
testl %eax, %eax
je 0x3c8d
movq %rbx, %rdi
callq 0x420d
movq %rbx, %rdi
callq 0x41e9
xorl %edi, %edi
cmpl %eax, %r13d
sete %dil
movq %r15, %rsi
movl %ebp, %edx
movq %r12, %rcx
leaq 0x1705(%rip), %r8       # 0x5384
xorl %eax, %eax
callq 0x239c
decl %r13d
testl %eax, %eax
jne 0x3c1f
callq 0x2bc0
movq %rbx, %rdi
callq 0x4219
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1997
movq %rax, %r14
movq %r15, %rdi
callq 0x1997
movq %rax, %rcx
pushq $0xa
popq %rsi
movq %r14, %rax
xorl %edx, %edx
divq %rsi
addl $0xa, %edx
movw %dx, 0x8(%rbx)
movq %r14, %rax
shrq $0x18, %rax
xorl %edx, %edx
divq %rsi
addl $0xa, %edx
movw %dx, 0xa(%rbx)
shrq $0x30, %r14
movw $0xa, %si
movl %r14d, %eax
xorl %edx, %edx
divw %si
addl $0xa, %edx
movw %dx, 0xc(%rbx)
movl %ecx, %eax
orl $0x1, %eax
movl %eax, 0x10(%rbx)
shrq $0x20, %rcx
orl $0x1, %ecx
movl %ecx, 0x14(%rbx)
andl $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movb 0x8(%rdi), %cl
movb 0xa(%rdi), %al
movl %esi, %edx
shrl %cl, %edx
xorl %esi, %edx
imull 0x10(%rdi), %edx
movl %edx, %esi
movl %eax, %ecx
shrl %cl, %esi
xorl %edx, %esi
imull 0x14(%rdi), %esi
movb 0xc(%rdi), %cl
movl %esi, %eax
shrl %cl, %eax
xorl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x502c
cmpq $0x2, %rax
jne 0x2067
movq %r14, %rdi
callq 0x50ce
movq %rax, %r15
movq %r14, %rdi
callq 0x5046
movq %rax, %rdi
callq 0x50ce
movq %r15, %rdi
movq %rax, %rsi
callq 0x6429
movzbl %al, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x676a
movq 0x9f72(%rip), %rax      # 0xbfe0
movq (%rax), %rbx
movq %r14, %rdi
callq 0x502c
leaq 0x5184(%rip), %rsi      # 0x7204
leaq 0x4fae(%rip), %rdx      # 0x7035
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %rax, %r8
xorl %eax, %eax
callq 0x1220
pushq $0x1
popq %rdi
callq 0x11b0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x502c
cmpq $0x2, %rax
jne 0x20ee
movq %r14, %rdi
callq 0x50ce
movq %rax, %r15
movq %r14, %rdi
callq 0x5046
movq %rax, %rdi
callq 0x50ce
movq %r15, %rdi
movq %rax, %rsi
callq 0x642e
movzbl %al, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x676a
movq 0x9eeb(%rip), %rax      # 0xbfe0
movq (%rax), %rbx
movq %r14, %rdi
callq 0x502c
leaq 0x50fd(%rip), %rsi      # 0x7204
leaq 0x4f2b(%rip), %rdx      # 0x7039
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %rax, %r8
xorl %eax, %eax
callq 0x1220
pushq $0x1
popq %rdi
callq 0x11b0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x502c
cmpq $0x2, %rax
jne 0x2175
movq %r14, %rdi
callq 0x50ce
movq %rax, %r15
movq %r14, %rdi
callq 0x5046
movq %rax, %rdi
callq 0x50ce
movq %r15, %rdi
movq %rax, %rsi
callq 0x6433
movzbl %al, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x676a
movq 0x9e64(%rip), %rax      # 0xbfe0
movq (%rax), %rbx
movq %r14, %rdi
callq 0x502c
leaq 0x5076(%rip), %rsi      # 0x7204
leaq 0x4ea9(%rip), %rdx      # 0x703e
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %rax, %r8
xorl %eax, %eax
callq 0x1220
pushq $0x1
popq %rdi
callq 0x11b0
// File: /workspace/github_c_makefile_star2_O2/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_equal
struct value*
builtin_equal(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_GTE("=", args, 2);
    ASSERT_TYPE_ALL("=", args, VALUE_NUMBER);

    struct value* item = CAR(args);
    args = CDR(args);

    while (!value_is_empty_list(args)) {
        if (!value_is_equal(item, CAR(args))) return vm_make_boolean(vm, false);
        item = CAR(args);
        args = CDR(args);
    }

    return vm_make_boolean(vm, true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x502c
cmpq $0x2, %rax
jl 0x22fd
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x502c
cmpq %r15, %rax
jle 0x2277
movq %r14, %rdi
movq %r15, %rsi
callq 0x5075
cmpl $0x4, (%rax)
jne 0x22ad
incq %r15
jmp 0x223e
movq %r14, %rdi
callq 0x50ce
movq %r15, %rdi
movq %rax, %rsi
callq 0x6433
testb %al, %al
je 0x2294
movq %r14, %rdi
callq 0x50ce
movq %rax, %r15
movq %r14, %rdi
callq 0x5046
movq %rax, %r14
movl (%rax), %ebp
cmpl $0x1, %ebp
jne 0x2260
xorl %esi, %esi
cmpl $0x1, %ebp
sete %sil
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x676a
movq 0x9d2c(%rip), %rax      # 0xbfe0
movq (%rax), %rbx
pushq $0x4
popq %rdi
callq 0x6409
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x5075
movl (%rax), %edi
callq 0x6409
leaq 0x4fa8(%rip), %rsi      # 0x7283
leaq 0x4d6e(%rip), %rdx      # 0x7050
movq %rbx, %rdi
movl %r15d, %ecx
movq %r12, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x1220
pushq $0x1
popq %rdi
callq 0x11b0
movq 0x9cdc(%rip), %rax      # 0xbfe0
movq (%rax), %rbx
movq %r14, %rdi
callq 0x502c
leaq 0x4f2f(%rip), %rsi      # 0x7245
leaq 0x4d33(%rip), %rdx      # 0x7050
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %rax, %r8
xorl %eax, %eax
callq 0x1220
jmp 0x22f5
// File: /workspace/github_c_makefile_star2_O2/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_less
struct value*
builtin_less(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_GTE("<", args, 2);
    ASSERT_TYPE_ALL("<", args, VALUE_NUMBER);

    struct value* item = CAR(args);
    args = CDR(args);

    while (!value_is_empty_list(args)) {
        if (!(item->as.number < CAR(args)->as.number)) return vm_make_boolean(vm, false);
        item = CAR(args);
        args = CDR(args);
    }

    return vm_make_boolean(vm, true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x502c
cmpq $0x2, %rax
jl 0x240c
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x502c
cmpq %r15, %rax
jle 0x2386
movq %r14, %rdi
movq %r15, %rsi
callq 0x5075
cmpl $0x4, (%rax)
jne 0x23bc
incq %r15
jmp 0x2352
movq 0x10(%r15), %r15
movq %r14, %rdi
callq 0x50ce
cmpq 0x10(%rax), %r15
jge 0x23a3
movq %r14, %rdi
callq 0x50ce
movq %rax, %r15
movq %r14, %rdi
callq 0x5046
movq %rax, %r14
movl (%rax), %ebp
cmpl $0x1, %ebp
jne 0x2374
xorl %esi, %esi
cmpl $0x1, %ebp
sete %sil
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x676a
movq 0x9c1d(%rip), %rax      # 0xbfe0
movq (%rax), %rbx
pushq $0x4
popq %rdi
callq 0x6409
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x5075
movl (%rax), %edi
callq 0x6409
leaq 0x4e99(%rip), %rsi      # 0x7283
leaq 0x4c5c(%rip), %rdx      # 0x704d
movq %rbx, %rdi
movl %r15d, %ecx
movq %r12, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x1220
pushq $0x1
popq %rdi
callq 0x11b0
movq 0x9bcd(%rip), %rax      # 0xbfe0
movq (%rax), %rbx
movq %r14, %rdi
callq 0x502c
leaq 0x4e20(%rip), %rsi      # 0x7245
leaq 0x4c21(%rip), %rdx      # 0x704d
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %rax, %r8
xorl %eax, %eax
callq 0x1220
jmp 0x2404
// File: /workspace/github_c_makefile_star2_O2/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_greater
struct value*
builtin_greater(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_GTE(">", args, 2);
    ASSERT_TYPE_ALL(">", args, VALUE_NUMBER);

    struct value* item = CAR(args);
    args = CDR(args);

    while (!value_is_empty_list(args)) {
        if (!(item->as.number > CAR(args)->as.number)) return vm_make_boolean(vm, false);
        item = CAR(args);
        args = CDR(args);
    }

    return vm_make_boolean(vm, true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x502c
cmpq $0x2, %rax
jl 0x251b
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x502c
cmpq %r15, %rax
jle 0x2495
movq %r14, %rdi
movq %r15, %rsi
callq 0x5075
cmpl $0x4, (%rax)
jne 0x24cb
incq %r15
jmp 0x2461
movq 0x10(%r15), %r15
movq %r14, %rdi
callq 0x50ce
cmpq 0x10(%rax), %r15
jle 0x24b2
movq %r14, %rdi
callq 0x50ce
movq %rax, %r15
movq %r14, %rdi
callq 0x5046
movq %rax, %r14
movl (%rax), %ebp
cmpl $0x1, %ebp
jne 0x2483
xorl %esi, %esi
cmpl $0x1, %ebp
sete %sil
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x676a
movq 0x9b0e(%rip), %rax      # 0xbfe0
movq (%rax), %rbx
pushq $0x4
popq %rdi
callq 0x6409
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x5075
movl (%rax), %edi
callq 0x6409
leaq 0x4d8a(%rip), %rsi      # 0x7283
leaq 0x5910(%rip), %rdx      # 0x7e10
movq %rbx, %rdi
movl %r15d, %ecx
movq %r12, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x1220
pushq $0x1
popq %rdi
callq 0x11b0
movq 0x9abe(%rip), %rax      # 0xbfe0
movq (%rax), %rbx
movq %r14, %rdi
callq 0x502c
leaq 0x4d11(%rip), %rsi      # 0x7245
leaq 0x58d5(%rip), %rdx      # 0x7e10
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %rax, %r8
xorl %eax, %eax
callq 0x1220
jmp 0x2513
// File: /workspace/github_c_makefile_star2_O2/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_less_equal
struct value*
builtin_less_equal(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_GTE("<=", args, 2);
    ASSERT_TYPE_ALL("<=", args, VALUE_NUMBER);

    struct value* item = CAR(args);
    args = CDR(args);

    while (!value_is_empty_list(args)) {
        if (!(item->as.number <= CAR(args)->as.number)) return vm_make_boolean(vm, false);
        item = CAR(args);
        args = CDR(args);
    }

    return vm_make_boolean(vm, true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x502c
cmpq $0x2, %rax
jl 0x262a
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x502c
cmpq %r15, %rax
jle 0x25a4
movq %r14, %rdi
movq %r15, %rsi
callq 0x5075
cmpl $0x4, (%rax)
jne 0x25da
incq %r15
jmp 0x2570
movq 0x10(%r15), %r15
movq %r14, %rdi
callq 0x50ce
cmpq 0x10(%rax), %r15
jg 0x25c1
movq %r14, %rdi
callq 0x50ce
movq %rax, %r15
movq %r14, %rdi
callq 0x5046
movq %rax, %r14
movl (%rax), %ebp
cmpl $0x1, %ebp
jne 0x2592
xorl %esi, %esi
cmpl $0x1, %ebp
sete %sil
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x676a
movq 0x99ff(%rip), %rax      # 0xbfe0
movq (%rax), %rbx
pushq $0x4
popq %rdi
callq 0x6409
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x5075
movl (%rax), %edi
callq 0x6409
leaq 0x4c7b(%rip), %rsi      # 0x7283
leaq 0x4a40(%rip), %rdx      # 0x704f
movq %rbx, %rdi
movl %r15d, %ecx
movq %r12, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x1220
pushq $0x1
popq %rdi
callq 0x11b0
movq 0x99af(%rip), %rax      # 0xbfe0
movq (%rax), %rbx
movq %r14, %rdi
callq 0x502c
leaq 0x4c02(%rip), %rsi      # 0x7245
leaq 0x4a05(%rip), %rdx      # 0x704f
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %rax, %r8
xorl %eax, %eax
callq 0x1220
jmp 0x2622
// File: /workspace/github_c_makefile_star2_O2/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_greater_equal
struct value*
builtin_greater_equal(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_GTE(">=", args, 2);
    ASSERT_TYPE_ALL(">=", args, VALUE_NUMBER);

    struct value* item = CAR(args);
    args = CDR(args);

    while (!value_is_empty_list(args)) {
        if (!(item->as.number >= CAR(args)->as.number)) return vm_make_boolean(vm, false);
        item = CAR(args);
        args = CDR(args);
    }

    return vm_make_boolean(vm, true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x502c
cmpq $0x2, %rax
jl 0x2739
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x502c
cmpq %r15, %rax
jle 0x26b3
movq %r14, %rdi
movq %r15, %rsi
callq 0x5075
cmpl $0x4, (%rax)
jne 0x26e9
incq %r15
jmp 0x267f
movq 0x10(%r15), %r15
movq %r14, %rdi
callq 0x50ce
cmpq 0x10(%rax), %r15
jl 0x26d0
movq %r14, %rdi
callq 0x50ce
movq %rax, %r15
movq %r14, %rdi
callq 0x5046
movq %rax, %r14
movl (%rax), %ebp
cmpl $0x1, %ebp
jne 0x26a1
xorl %esi, %esi
cmpl $0x1, %ebp
sete %sil
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x676a
movq 0x98f0(%rip), %rax      # 0xbfe0
movq (%rax), %rbx
pushq $0x4
popq %rdi
callq 0x6409
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x5075
movl (%rax), %edi
callq 0x6409
leaq 0x4b6c(%rip), %rsi      # 0x7283
leaq 0x4934(%rip), %rdx      # 0x7052
movq %rbx, %rdi
movl %r15d, %ecx
movq %r12, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x1220
pushq $0x1
popq %rdi
callq 0x11b0
movq 0x98a0(%rip), %rax      # 0xbfe0
movq (%rax), %rbx
movq %r14, %rdi
callq 0x502c
leaq 0x4af3(%rip), %rsi      # 0x7245
leaq 0x48f9(%rip), %rdx      # 0x7052
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %rax, %r8
xorl %eax, %eax
callq 0x1220
jmp 0x2731
// File: /workspace/github_c_makefile_star2_O2/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_add
struct value*
builtin_add(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_GTE("+", args, 2);
    ASSERT_TYPE_ALL("+", args, VALUE_NUMBER);

    long res = 0;
    while (!value_is_empty_list(args)) {
        res += CAR(args)->as.number;
        args = CDR(args);
    }

    return vm_make_number(vm, res);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x502c
cmpq $0x2, %rax
jl 0x2837
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x502c
cmpq %r15, %rax
jle 0x27b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5075
cmpl $0x4, (%rax)
jne 0x27e7
incq %r15
jmp 0x278e
xorl %r15d, %r15d
cmpl $0x1, (%rbx)
je 0x27d1
movq %rbx, %rdi
callq 0x50ce
addq 0x10(%rax), %r15
movq %rbx, %rdi
callq 0x5046
movq %rax, %rbx
jmp 0x27b3
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x67d8
movq 0x97f2(%rip), %rax      # 0xbfe0
movq (%rax), %r14
pushq $0x4
popq %rdi
callq 0x6409
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5075
movl (%rax), %edi
callq 0x6409
leaq 0x4a6e(%rip), %rsi      # 0x7283
leaq 0x4839(%rip), %rdx      # 0x7055
movq %r14, %rdi
movl %r15d, %ecx
movq %r12, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x1220
pushq $0x1
popq %rdi
callq 0x11b0
movq 0x97a2(%rip), %rax      # 0xbfe0
movq (%rax), %r14
movq %rbx, %rdi
callq 0x502c
leaq 0x49f5(%rip), %rsi      # 0x7245
leaq 0x47fe(%rip), %rdx      # 0x7055
pushq $0x2
popq %rcx
movq %r14, %rdi
movq %rax, %r8
xorl %eax, %eax
callq 0x1220
jmp 0x282f