LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/serge-404[P]CPM32/cpm.c
// Function: cpm_file_delete
byte cpm_file_delete( byte *fcbaddr)
{
    struct FCB *fcb = (struct FCB *)fcbaddr;
    int i;
    HANDLE hFndFile;
    WIN32_FIND_DATA aFindData;
    char *fname;
    byte st = 0xff;

    if ( memcmp( fcbaddr, "\1$$$     SUB", 1+8+3) == 0) abort_submit = TRUE;

    if (( i = fcb->d[ 0]) > 0 && --i < MAXFCB && 
		fcbs[ i].addr == fcbaddr && fcbs[ i].fp) {
DEBUGOUT( stderr, "REUSE %d - ", i);
	fclose( fcbs[ i].fp); fcbs[ i].fp = NULL;
    }

    if (( fname = mk_filename( filename, fcbaddr)) == NULL) return 0xff;
    hFndFile = FindFirstFile( filename, &aFindData);
    if ( hFndFile == INVALID_HANDLE_VALUE) return 0xff;
    do {
	char *p = aFindData.cAlternateFileName;
	if ( !*p) p = aFindData.cFileName;
	if ( *p != '.') {
	    strcpy( fname, p);
	    if ( remove( filename) == 0) st = 0;
	}
    } while( FindNextFile( hFndFile, &aFindData));
    FindClose( hFndFile);

    return st;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdi, %rbx
movabsq $0x2020202024242401, %rax # imm = 0x2020202024242401
xorq (%rdi), %rax
movl 0x8(%rdi), %ecx
xorq $0x42555320, %rcx       # imm = 0x42555320
orq %rax, %rcx
jne 0xa0cb
movl $0x1, 0x10c845(%rip)    # 0x116910
movzbl 0x10(%rbx), %edx
testl %edx, %edx
je 0xa112
cmpb $0x40, %dl
ja 0xa112
decl %edx
movl %edx, %eax
shlq $0x5, %rax
leaq 0x10c029(%rip), %r14    # 0x116110
cmpq %rbx, 0x10(%rax,%r14)
jne 0xa112
addq %rax, %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa112
cmpl $0x0, 0x10a214(%rip)    # 0x114314
jne 0xa1c2
callq 0x20c0
movq $0x0, (%r14)
leaq 0x10b9c7(%rip), %rdi    # 0x115ae0
movq %rbx, %rsi
callq 0x91e6
movb $-0x1, %bl
testq %rax, %rax
je 0xa1ae
movq %rax, %r14
leaq 0x10b9aa(%rip), %rdi    # 0x115ae0
leaq 0x8(%rsp), %rsi
callq 0x939f
testq %rax, %rax
je 0xa1ae
movq %rax, %r15
leaq 0x124(%rsp), %rbp
movb $-0x1, %bl
leaq 0x20(%rsp), %r13
leaq 0x8(%rsp), %r12
cmpb $0x0, 0x124(%rsp)
movq %rbp, %rsi
cmoveq %r13, %rsi
cmpb $0x2e, (%rsi)
je 0xa18c
movq %r14, %rdi
callq 0x2090
leaq 0x10b961(%rip), %rdi    # 0x115ae0
callq 0x2080
testl %eax, %eax
movzbl %bl, %ebx
cmovel %eax, %ebx
movq %r15, %rdi
movq %r12, %rsi
callq 0x95dc
testl %eax, %eax
jne 0xa15c
movq %r15, %rdi
callq 0x21a0
movq $0x0, 0x10bd32(%rip) # 0x115ee0
movl %ebx, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x9e2f(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x6cf6(%rip), %rsi      # 0x10ec9
xorl %eax, %eax
callq 0x2200
movq (%r14), %rdi
jmp 0xa106
// File: /workspace/github_c_makefile_star2_O3/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 0x10c4c1(%rip), %rax    # 0x116918
testq %rax, %rax
jne 0xa48f
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movaps %xmm0, 0x20(%rdi)
movq $0x0, 0x30(%rdi)
movl $0x4e, 0x14(%rdi)
movl $0x1, 0xc(%rdi)
callq 0x22b0
movq %rax, 0x10c489(%rip)    # 0x116918
subq %rax, %r14
movabsq $-0x7777777777777777, %rdi # imm = 0x8888888888888889
movq %r14, %rax
imulq %rdi
movq %rdx, %rsi
addq %r14, %rsi
movq %rsi, %rax
shrq $0x3f, %rax
sarq $0x5, %rsi
addq %rax, %rsi
imulq $0x3c, %rsi, %rcx
movq %r14, %rax
subq %rcx, %rax
movsbl %al, %ecx
imull $0x67, %ecx, %ecx
movl $0xffff, %r8d           # imm = 0xFFFF
movl %ecx, %edx
andl %r8d, %edx
shrl $0xf, %edx
shrl $0x8, %ecx
sarb $0x2, %cl
addb %dl, %cl
movzbl %cl, %ecx
leal (%rcx,%rcx), %edx
leal (%rdx,%rdx,4), %edx
subb %dl, %al
shlb $0x4, %cl
addb %al, %cl
movb %cl, 0x4(%rbx)
movq %rsi, %rax
imulq %rdi
addq %rsi, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x5, %rdx
addq %rax, %rdx
imulq $0x3c, %rdx, %rax
subq %rax, %rsi
movabsq $0x48d159e26af37c05, %rdx # imm = 0x48D159E26AF37C05
movq %r14, %rax
imulq %rdx
movq %rdx, %rdi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xa, %rdi
addq %rax, %rdi
movsbl %sil, %eax
imull $0x67, %eax, %eax
movl %eax, %edx
andl %r8d, %edx
shrl $0xf, %edx
shrl $0x8, %eax
sarb $0x2, %al
addb %dl, %al
movzbl %al, %eax
leal (%rax,%rax), %edx
leal (%rdx,%rdx,4), %edx
subb %dl, %sil
shlb $0x4, %al
addb %sil, %al
movb %al, 0x3(%rbx)
movabsq $0x2aaaaaaaaaaaaaab, %rdx # imm = 0x2AAAAAAAAAAAAAAB
movq %rdi, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x2, %rdx
addq %rax, %rdx
shlq $0x3, %rdx
leaq (%rdx,%rdx,2), %rax
subq %rax, %rdi
movabsq $0x1845c8a0ce512957, %rdx # imm = 0x1845C8A0CE512957
movq %r14, %rax
imulq %rdx
movq %rdx, %rax
shrq $0xd, %rax
shrq $0x3f, %rdx
movsbl %dil, %esi
imull $0x67, %esi, %esi
andl %esi, %r8d
shrl $0xf, %r8d
shrl $0x8, %esi
sarb $0x2, %sil
addb %r8b, %sil
movzbl %sil, %esi
leal (%rsi,%rsi), %r8d
leal (%r8,%r8,4), %r8d
subb %r8b, %dil
shlb $0x4, %sil
addb %dil, %sil
movb %sil, 0x2(%rbx)
addl %edx, %eax
incl %eax
movb %al, (%rbx)
movb %ah, 0x1(%rbx)
movl %ecx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x9c14(%rip)      # 0x14208
movw $0x80, 0x9c0d(%rip)     # 0x1420a
movq 0x109e3c(%rip), %rdx    # 0x114440
leaq 0x10b4d5(%rip), %r14    # 0x115ae0
leaq 0x68c3(%rip), %rsi      # 0x10ed5
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2380
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x939f
testq %rax, %rax
je 0xa645
movq %rax, %rdi
callq 0x21a0
movq $0x0, 0x10b89d(%rip) # 0x115ee0
movb $-0x1, %bl
movl %ebx, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10c2cc(%rip), %rsi    # 0x116928
testq %rsi, %rsi
jne 0xa6a8
cmpl $0x0, 0x10c2b8(%rip)    # 0x116920
jne 0xa6a8
leaq 0x686b(%rip), %rdi      # 0x10edc
callq 0x2040
testq %rax, %rax
leaq 0x6863(%rip), %rdi      # 0x10ee3
cmovneq %rax, %rdi
leaq 0x685d(%rip), %rsi      # 0x10ee8
callq 0x2330
movq %rax, %rsi
movq %rax, 0x10c28e(%rip)    # 0x116928
xorl %eax, %eax
testq %rsi, %rsi
sete %al
movl %eax, 0x10c278(%rip)    # 0x116920
testq %rsi, %rsi
je 0xa6b6
movzbl %bl, %edi
popq %rbx
jmp 0x21e0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10c278(%rip), %rdi    # 0x116938
testq %rdi, %rdi
jne 0xa706
cmpl $0x0, 0x10c264(%rip)    # 0x116930
jne 0xa706
leaq 0x6816(%rip), %rdi      # 0x10eeb
callq 0x2040
testq %rax, %rax
je 0xa723
leaq 0x677d(%rip), %rsi      # 0x10e63
movq %rax, %rdi
callq 0x2330
movq %rax, %rdi
movq %rax, 0x10c240(%rip)    # 0x116938
xorl %eax, %eax
testq %rdi, %rdi
sete %al
movl %eax, 0x10c22a(%rip)    # 0x116930
testq %rdi, %rdi
je 0xa71f
callq 0x23b0
movl %eax, %ecx
cmpl $-0x1, %eax
movl $0x1a, %eax
cmovnel %ecx, %eax
jmp 0xa721
movb $0x1a, %al
popq %rcx
retq
movq 0x10c216(%rip), %rdi    # 0x116940
testq %rdi, %rdi
je 0xa738
movq %rdi, 0x10c202(%rip)    # 0x116938
jmp 0xa70b
leaq 0x67b3(%rip), %rdi      # 0x10ef2
callq 0x2040
movq %rax, %rcx
testq %rax, %rax
leaq 0x67a8(%rip), %rax      # 0x10ef9
cmovneq %rcx, %rax
jmp 0xa6df
// File: /workspace/github_c_makefile_star2_O3/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 0x10c1df(%rip), %rsi    # 0x116940
testq %rsi, %rsi
jne 0xa7a7
cmpl $0x0, 0x10c1db(%rip)    # 0x116948
jne 0xa7a7
leaq 0x6788(%rip), %rdi      # 0x10efe
callq 0x2040
testq %rax, %rax
je 0xa7b7
leaq 0x66dc(%rip), %rsi      # 0x10e63
movq %rax, %rdi
callq 0x2330
movq %rax, %rsi
movq %rax, 0x10c1a7(%rip)    # 0x116940
xorl %eax, %eax
testq %rsi, %rsi
sete %al
movl %eax, 0x10c1a1(%rip)    # 0x116948
testq %rsi, %rsi
je 0xa7b5
movzbl %bl, %edi
popq %rbx
jmp 0x21e0
popq %rbx
retq
movq 0x10c17a(%rip), %rsi    # 0x116938
testq %rsi, %rsi
je 0xa7cc
movq %rsi, 0x10c176(%rip)    # 0x116940
jmp 0xa7ac
leaq 0x671f(%rip), %rdi      # 0x10ef2
callq 0x2040
movq %rax, %rcx
testq %rax, %rax
leaq 0x6714(%rip), %rax      # 0x10ef9
cmovneq %rcx, %rax
jmp 0xa780
// File: /workspace/github_c_makefile_star2_O3/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 0x9a00(%rip), %eax      # 0x1422c
movl 0x99fe(%rip), %ecx      # 0x14230
movl %ecx, 0x99f4(%rip)      # 0x1422c
movl 0x99f6(%rip), %ecx      # 0x14234
movl %ecx, 0x99ec(%rip)      # 0x14230
movl $0xffffffff, 0x99e6(%rip) # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6696(%rip), %rdi      # 0x10f05
xorl %eax, %eax
callq 0x2100
movl $0x1, %r15d
callq 0x21f0
movb %al, -0x1(%rsp,%r15)
incq %r15
cmpl $0x52, %eax
jne 0xa87c
movl %r15d, %eax
movb $0x0, (%rsp,%rax)
leaq 0x666e(%rip), %rsi      # 0x10f0a
movq %rsp, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x22a0
movq 0x9725(%rip), %rax      # 0x13fd8
movq (%rax), %rdi
xorl %esi, %esi
movl $0x2, %edx
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x22c0
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0x10(%rsp), %r14
movl $0x5413, %esi           # imm = 0x5413
xorl %edi, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2160
movzwl 0x2(%r14), %r12d
movzwl (%r14), %r13d
leaq 0x8(%rsp), %r14
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xa84f
addl (%r15), %ebp
addl (%r14), %ebx
leal -0x1(%r12), %eax
testl %ebp, %ebp
movl $0x0, %ecx
cmovgl %ebp, %ecx
cmpl %r12d, %ebp
cmovgel %eax, %ecx
leal -0x1(%r13), %eax
testl %ebx, %ebx
movl $0x0, %edx
cmovgl %ebx, %edx
cmpl %r13d, %ebx
cmovgel %eax, %edx
movswl %dx, %esi
movswl %cx, %edx
leaq 0x6a93(%rip), %rdi      # 0x113e3
xorl %eax, %eax
callq 0x2100
movq 0x9672(%rip), %rax      # 0x13fd0
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_O3/serge-404[P]CPM32/cpm.c
// Function: cpm_const
byte cpm_const( void)
{
#ifdef __linux__
	if (kbhit()) 
		return 0xff;
	else
		return 0;
#else
		DWORD t;
    static DWORD t0, ct;

    if ( conin  ? kbhit() 
		: WaitForSingleObject( hStdIn, 0) != WAIT_TIMEOUT) {
	return 0xff;
    }
    if ( kbwait) {
	t = GetTickCount();
	if ( t != t0) ct = (( t - t0) * 4) >> kbwait;
	if ( ct == 0) Sleep( 1 << (kbwait - 1));
	else --ct;
	t0 = t;
    }
    return 0;
#endif
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
leaq 0x10(%rsp), %rsi
movups %xmm0, 0x68(%rsi)
movups %xmm0, 0x58(%rsi)
movups %xmm0, 0x48(%rsi)
movups %xmm0, 0x38(%rsi)
movups %xmm0, 0x28(%rsi)
movups %xmm0, 0x18(%rsi)
movups %xmm0, 0x8(%rsi)
movq $0x0, 0x78(%rsi)
movq $0x1, (%rsi)
xorl %ebx, %ebx
movl $0x1, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2260
negl %eax
sbbl %ebx, %ebx
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0x9473(%rip), %rdx      # 0x14260
xorl %edi, %edi
xorl %esi, %esi
callq 0x2300
leaq 0x2(%rbx), %r14
movzbl (%rbx), %esi
movq 0x91d4(%rip), %rax      # 0x13fd8
movq (%rax), %rdx
movq %r14, %rdi
callq 0x21d0
testq %rax, %rax
jne 0xae2c
callq 0x2b05
decl 0x9409(%rip)            # 0x14228
je 0xae8a
movb $0x0, 0x2(%r14)
movw $0xa1a, (%r14)          # imm = 0xA1A
callq 0x2b05
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, 0x10bafd(%rip)    # 0x116950
je 0xae80
cmpl $0x0, 0x10baf8(%rip)    # 0x116954
je 0xae80
leaq 0x659b(%rip), %rdi      # 0x11400
movl $0x1, %esi
xorl %eax, %eax
callq 0x2100
movq 0x9158(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
callq 0x2290
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xabb7
xorl %edi, %edi
callq 0x2390
// File: /workspace/github_c_makefile_star2_O3/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 0x13ac
callq 0x1658
cmpl $0x3, %ebx
jne 0x13e8
movq 0x8(%r15), %r14
callq 0x1070
movl $0x0, (%rax)
movq 0x10(%r15), %r12
testq %r12, %r12
jne 0x140a
leaq 0xc68(%rip), %rdi       # 0x2038
leaq 0xc6b(%rip), %rsi       # 0x2042
leaq 0xc7a(%rip), %rcx       # 0x2058
movl $0xa7, %edx
callq 0x1090
movq 0x2c09(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xc0b(%rip), %rdi       # 0x2004
movl $0x1d, %esi
movl $0x1, %edx
callq 0x1130
jmp 0x1454
movq %rax, %rbx
movq %rsp, %r15
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1040
movq (%r15), %rdx
movl $0x16, %ecx
cmpq %r12, %rdx
je 0x143e
cmpb $0x0, (%rdx)
jne 0x143e
leaq -0x3(%rax), %rdx
movl $0x22, %ecx
cmpq $-0x3, %rdx
ja 0x145e
movl %ecx, (%rbx)
leaq 0xbdb(%rip), %rdi       # 0x2022
xorl %eax, %eax
callq 0x16d8
movl $0x0, (%rbx)
movl $0x1, %edi
callq 0x1120
cmpl $0x0, (%rbx)
jne 0x1440
cmpq $0x1, %rax
jne 0x14c3
movq %r14, %rdi
callq 0x1541
movl $0x1, %edi
callq 0x18f8
movq %r14, %rdi
callq 0x1541
xorl %edi, %edi
callq 0x18f8
leaq 0xc0c(%rip), %rdi       # 0x209d
xorl %eax, %eax
callq 0x17f7
movl $0x0, (%rbx)
movl $0x1, %edi
callq 0x18f8
leaq 0xb7c(%rip), %rdi       # 0x202b
xorl %eax, %eax
callq 0x17f7
movl $0x0, (%rbx)
xorl %edi, %edi
callq 0x1120
leaq 0x1c(%rsp), %r12
xorl %ebp, %ebp
leaq 0x13c(%rip), %r13       # 0x160d
leaq 0xbfa(%rip), %r14       # 0x20d2
movl %ebp, (%r12)
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
callq 0x10f0
testl %eax, %eax
jne 0x1528
incq %rbp
addq $0x8, %r15
addq $0x4, %r12
cmpq $0x3, %rbp
jne 0x14d8
xorl %r15d, %r15d
leaq 0xbda(%rip), %r14       # 0x20e5
movq (%rsp,%r15,8), %rdi
xorl %esi, %esi
callq 0x1140
testl %eax, %eax
jne 0x1528
incq %r15
cmpq $0x3, %r15
jne 0x150b
jmp 0x149e
movl %eax, %edi
callq 0x1160
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x17f7
jmp 0x144e
// File: /workspace/github_c_makefile_star2_O3/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 0xb54(%rip), %rdi       # 0x20ac
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x17f7
callq 0x1070
movq %rax, %rbx
movl %r15d, (%rax)
xorl %edi, %edi
xorl %eax, %eax
callq 0x17f7
movl $0x2, %ebp
movl %ebp, (%rbx)
xorl %edi, %edi
xorl %eax, %eax
callq 0x16d8
movl %r15d, (%rbx)
xorl %edi, %edi
xorl %eax, %eax
callq 0x17f7
movl %r15d, (%rbx)
leaq 0xb27(%rip), %r14       # 0x20c3
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x17f7
movl %ebp, (%rbx)
movq %r14, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x16d8
movl %r15d, (%rbx)
movl $0x1, %eax
movb $0x61, %cl
movabsq $0x5f5f5f5f5f5f5f5f, %rdx # imm = 0x5F5F5F5F5F5F5F5F
movb %cl, -0x1(%rsp,%rax)
movq %rdx, (%rsp,%rax)
movb $0x5f, 0x8(%rsp,%rax)
addq $0xa, %rax
incb %cl
cmpq $0x12d, %rax            # imm = 0x12D
jne 0x15cd
movq %rsp, %rdi
movb $0x0, 0x12c(%rdi)
xorl %eax, %eax
callq 0x17f7
movl $0x0, (%rbx)
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xad1(%rip), %r15       # 0x20f6
xorl %ebp, %ebp
movl $0x2, (%r14)
movq %r15, %rdi
movl %ebx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x16d8
movl $0x0, (%r14)
incl %ebp
cmpl $0xa, %ebp
jne 0x1627
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, 0x10(%rsp)
cmpl $0x2, %edi
jl 0x121f
movq 0x8(%rsi), %rdi
callq 0x1090
movl %eax, 0x2e51(%rip)      # 0x4070
leaq -0x6a(%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 0x2e35(%rip), %rdi      # 0x4080
callq 0x10b0
cmpl $0x0, 0x2e81(%rip)      # 0x40d8
jne 0x129f
leaq 0x2e48(%rip), %rbx      # 0x40a8
leaq 0x2e19(%rip), %r14      # 0x4080
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1080
cmpl $0x6e, %eax
je 0x128a
cmpl $0x0, 0x2e52(%rip)      # 0x40d8
je 0x126c
jmp 0x129f
leaq 0xd73(%rip), %rdi       # 0x2004
callq 0x1030
cmpl $0x0, 0x2e3b(%rip)      # 0x40d8
je 0x12ab
leaq 0xd74(%rip), %rdi       # 0x201a
callq 0x1030
leaq 0x2dce(%rip), %rdi      # 0x4080
callq 0x1060
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x2e88(%rip), %rdi      # 0x4088
callq 0x10b0
movl %eax, %edi
callq 0x1070
leaq 0x18f(%rip), %rsi       # 0x13a2
movl $0xe, %edi
callq 0x1080
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1050
cvtsi2sdq (%rbx), %xmm0
cvtsi2sdq 0x8(%rbx), %xmm1
mulsd 0xdca(%rip), %xmm1      # 0x2008
addsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1050
movq (%rbx), %r14
movq 0x8(%rbx), %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1050
xorps %xmm1, %xmm1
cvtsi2sdq (%rbx), %xmm1
xorps %xmm0, %xmm0
cvtsi2sdq 0x8(%rbx), %xmm0
mulsd 0xd8d(%rip), %xmm0      # 0x2008
addsd %xmm1, %xmm0
movapd %xmm0, %xmm1
subsd -0x20(%rbp), %xmm1
ucomisd 0xd80(%rip), %xmm1      # 0x2010
ja 0x1357
cvtsi2sd %r15, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
mulsd 0xd5d(%rip), %xmm2      # 0x2008
addsd %xmm1, %xmm2
leaq 0xd95(%rip), %rbx       # 0x204b
leaq 0xddb(%rip), %r14       # 0x2098
leaq -0x30(%rbp), %r15
movsd %xmm0, -0x38(%rbp)
subsd %xmm2, %xmm0
movsd 0xd46(%rip), %xmm1      # 0x2018
ucomisd %xmm0, %xmm1
jbe 0x1383
movl 0x2dba(%rip), %esi      # 0x409c
movq %rbx, %rdi
movb $0x1, %al
callq 0x1040
movb $0x0, 0x2dad(%rip)      # 0x40a0
xorl %edi, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x10c0
testl %eax, %eax
jns 0x130a
jmp 0x1370
callq 0x1090
cmpb $0x0, 0x2d8f(%rip)      # 0x40a0
je 0x1305
movq %r15, %rdi
xorl %esi, %esi
callq 0x1050
xorps %xmm1, %xmm1
cvtsi2sdq -0x30(%rbp), %xmm1
xorps %xmm0, %xmm0
cvtsi2sdq -0x28(%rbp), %xmm0
mulsd 0xcd1(%rip), %xmm0      # 0x2008
addsd %xmm1, %xmm0
movapd %xmm0, %xmm1
subsd -0x20(%rbp), %xmm1
ucomisd 0xcc4(%rip), %xmm1      # 0x2010
movsd -0x38(%rbp), %xmm2
jbe 0x12c1
leaq 0x2d2a(%rip), %rdi      # 0x4088
callq 0x1030
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xce5(%rip), %rsi       # 0x205c
movl $0x1, %edi
xorl %eax, %eax
callq 0x10a0
leaq 0xc96(%rip), %rdi       # 0x2020
leaq 0xc9f(%rip), %rsi       # 0x2030
leaq 0xca8(%rip), %rcx       # 0x2040
movl $0x2a, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/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 0x2cf2(%rip), %al       # 0x40a0
cmpb $0x1, %al
je 0x13e9
incl 0x2ce4(%rip)            # 0x409c
leaq 0x2cc9(%rip), %rdi      # 0x4088
xorl %esi, %esi
callq 0x10d0
testl %eax, %eax
js 0x1408
cmpl $0x1, %eax
je 0x141b
leaq 0x2cb2(%rip), %rdi      # 0x4088
callq 0x1030
movb $0x1, 0x2cbe(%rip)      # 0x40a0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xc76(%rip), %rdi       # 0x2066
leaq 0xc39(%rip), %rsi       # 0x2030
leaq 0xc73(%rip), %rcx       # 0x2071
movl $0x18, %edx
callq 0x1060
leaq 0xc77(%rip), %rsi       # 0x2086
movl $0x1, %edi
xorl %eax, %eax
callq 0x10a0
leaq 0x2c66(%rip), %rbx      # 0x4088
movq %rbx, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x10e0
leaq 0xc55(%rip), %rsi       # 0x208d
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O3/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 0x4460
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x4490
xorl %edi, %edi
testq %rbx, %rbx
setne %dil
leaq 0x164f(%rip), %rsi      # 0x5318
leaq 0x1766(%rip), %rcx      # 0x5436
leaq 0x1651(%rip), %r8       # 0x5328
movl $0x11, %edx
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x3d25
movq %rbx, %rdi
callq 0x4465
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x161a(%rip), %rsi      # 0x5318
leaq 0x1731(%rip), %rcx      # 0x5436
leaq 0x162a(%rip), %r8       # 0x5336
movl $0x12, %edx
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x3d25
movq %rbx, %rdi
popq %rbx
jmp 0x4495
callq 0x2e2b
// File: /workspace/github_c_makefile_star2_O3/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 0x4460
movq %rax, %rbx
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21b0
movq %rax, %r14
movl $0x1, %r13d
leaq 0x15bf(%rip), %r15      # 0x5318
leaq 0x16d6(%rip), %r12      # 0x5436
leaq 0x15ff(%rip), %rbp      # 0x5366
movq %rax, (%rsp)
cmpq $0x3e9, %r13            # imm = 0x3E9
je 0x3de5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x447f
movq %rbx, %rdi
callq 0x4465
movl %eax, %eax
xorl %edi, %edi
cmpq %rax, %r13
sete %dil
movq %r15, %rsi
movl $0x1f, %edx
movq %r12, %rcx
leaq 0x15a9(%rip), %r8       # 0x534d
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x3de0
movq %rbx, %rdi
callq 0x446a
xorl %edi, %edi
cmpq %rax, %r14
sete %dil
movq %r15, %rsi
movl $0x20, %edx
movq %r12, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x25cc
incq %r13
addq $0x4, %r14
testl %eax, %eax
jne 0x3d6b
callq 0x2e2b
movq %rbx, %rdi
callq 0x4495
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_O3/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 %r14d, %r14d
xorl %edi, %edi
callq 0x4460
movq %rax, %rbx
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21b0
movq %rax, %r13
leaq (%r14,%r13), %rsi
movq %rbx, %rdi
callq 0x447f
addq $0x4, %r14
cmpq $0xfa0, %r14            # imm = 0xFA0
jne 0x3e29
movq %r13, %r14
addq $0xf9c, %r14            # imm = 0xF9C
movl $0x3e7, %ebp            # imm = 0x3E7
leaq 0x14c0(%rip), %r15      # 0x5318
leaq 0x15d7(%rip), %r12      # 0x5436
movq %rbx, %rdi
callq 0x446a
xorl %edi, %edi
cmpq %rax, %r14
sete %dil
movq %r15, %rsi
movl $0x32, %edx
movq %r12, %rcx
leaq 0x14e4(%rip), %r8       # 0x5366
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x3eed
movq %rbx, %rdi
callq 0x4489
movq %rbx, %rdi
callq 0x4465
movl %eax, %eax
xorl %edi, %edi
cmpq %rax, %rbp
sete %dil
movq %r15, %rsi
movl $0x34, %edx
movq %r12, %rcx
leaq 0x14ca(%rip), %r8       # 0x5384
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x3eed
addq $-0x4, %r14
addq $-0x1, %rbp
jb 0x3e5f
movq %rbx, %rdi
callq 0x4495
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2030
callq 0x2e2b
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]hash-prospector/genetic.c
// Function: gene_gen
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:
movq (%rsi), %rax
movq 0x8(%rsi), %r9
leaq (%r9,%r9,4), %rcx
rolq $0x7, %rcx
leaq (%rcx,%rcx,8), %rcx
movq %r9, %r8
shlq $0x11, %r8
movq 0x10(%rsi), %rdx
xorq %rax, %rdx
movq %rdx, %r10
xorq %r9, %r10
xorq 0x18(%rsi), %r9
xorq %r9, %rax
xorq %r8, %rdx
rolq $0x2d, %r9
leaq (%r10,%r10,4), %r8
rolq $0x7, %r8
leaq (%r8,%r8,8), %r8
movq %r10, %r11
shlq $0x11, %r11
xorq %rax, %rdx
xorq %r10, %r9
xorq %rdx, %r10
movq %r10, 0x8(%rsi)
xorq %r9, %rax
movq %rax, (%rsi)
xorq %r11, %rdx
movq %rdx, 0x10(%rsi)
rolq $0x2d, %r9
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rdx
movq %r9, 0x18(%rsi)
shrl $0x2, %edx
andl $-0x2, %edx
leal (%rdx,%rdx,4), %eax
movl %ecx, %edx
subl %eax, %edx
addl $0xa, %edx
movw %dx, 0x8(%rdi)
movq %rcx, %rsi
shrq $0x18, %rsi
movabsq $0x199999999999999a, %rdx # imm = 0x199999999999999A
movq %rsi, %rax
mulq %rdx
addl %edx, %edx
leal (%rdx,%rdx,4), %eax
subl %eax, %esi
addl $0xa, %esi
movw %si, 0xa(%rdi)
shrq $0x30, %rcx
imull $0xcccd, %ecx, %eax     # imm = 0xCCCD
shrl $0x12, %eax
andl $-0x2, %eax
leal (%rax,%rax,4), %eax
negl %eax
addl %ecx, %eax
addl $0xa, %eax
movw %ax, 0xc(%rdi)
movl %r8d, %eax
orl $0x1, %eax
movl %eax, 0x10(%rdi)
shrq $0x20, %r8
orl $0x1, %r8d
movl %r8d, 0x14(%rdi)
movl $0x0, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5a98
cmpq $0x2, %rax
jne 0x3e8b
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %rdi
callq 0x5b2b
movq %r15, %rdi
movq %rax, %rsi
callq 0x6cf5
movzbl %al, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x70c3
movq %r14, %rdi
callq 0x12a5
// File: /workspace/github_c_makefile_star2_O3/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 0x5a98
cmpq $0x2, %rax
jne 0x3ee2
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %rdi
callq 0x5b2b
movq %r15, %rdi
movq %rax, %rsi
callq 0x6cfa
movzbl %al, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x70c3
movq %r14, %rdi
callq 0x12db
// File: /workspace/github_c_makefile_star2_O3/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 0x5a98
cmpq $0x2, %rax
jne 0x3f39
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %rdi
callq 0x5b2b
movq %r15, %rdi
movq %rax, %rsi
callq 0x6cff
movzbl %al, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x70c3
movq %r14, %rdi
callq 0x1311
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x2, %rax
jl 0x4040
movq %r14, %rdi
callq 0x5a98
testq %rax, %rax
jle 0x3fcd
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x5acc
cmpl $0x4, (%rax)
jne 0x4035
incq %r15
movq %r14, %rdi
callq 0x5a98
cmpq %r15, %rax
jg 0x3fad
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movb $0x1, %bpl
cmpl $0x1, (%rax)
je 0x401f
movq %rax, %r14
movq %r14, %rdi
callq 0x5b2b
movq %r15, %rdi
movq %rax, %rsi
callq 0x6cff
movl %eax, %ebp
testb %al, %al
je 0x401f
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %r14
cmpl $0x1, (%rax)
jne 0x3feb
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x70c3
movq %r15, %rdi
movq %r14, %rsi
callq 0x13b6
movq %r14, %rdi
callq 0x1380
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x2, %rax
jl 0x4107
movq %r14, %rdi
callq 0x5a98
testq %rax, %rax
jle 0x4097
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x5acc
cmpl $0x4, (%rax)
jne 0x40fc
incq %r15
movq %r14, %rdi
callq 0x5a98
cmpq %r15, %rax
jg 0x4077
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movb $0x1, %bpl
cmpl $0x1, (%rax)
je 0x40e6
movq %rax, %r14
movq 0x10(%r15), %r15
movq %r14, %rdi
callq 0x5b2b
cmpq 0x10(%rax), %r15
setl %bpl
jge 0x40e6
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %r14
cmpl $0x1, (%rax)
jne 0x40b5
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x70c3
movq %r15, %rdi
movq %r14, %rsi
callq 0x1449
movq %r14, %rdi
callq 0x1413
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x2, %rax
jl 0x41ce
movq %r14, %rdi
callq 0x5a98
testq %rax, %rax
jle 0x415e
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x5acc
cmpl $0x4, (%rax)
jne 0x41c3
incq %r15
movq %r14, %rdi
callq 0x5a98
cmpq %r15, %rax
jg 0x413e
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movb $0x1, %bpl
cmpl $0x1, (%rax)
je 0x41ad
movq %rax, %r14
movq 0x10(%r15), %r15
movq %r14, %rdi
callq 0x5b2b
cmpq 0x10(%rax), %r15
setg %bpl
jle 0x41ad
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %r14
cmpl $0x1, (%rax)
jne 0x417c
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x70c3
movq %r15, %rdi
movq %r14, %rsi
callq 0x14dc
movq %r14, %rdi
callq 0x14a6
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x2, %rax
jl 0x4295
movq %r14, %rdi
callq 0x5a98
testq %rax, %rax
jle 0x4225
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x5acc
cmpl $0x4, (%rax)
jne 0x428a
incq %r15
movq %r14, %rdi
callq 0x5a98
cmpq %r15, %rax
jg 0x4205
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movb $0x1, %bpl
cmpl $0x1, (%rax)
je 0x4274
movq %rax, %r14
movq 0x10(%r15), %r15
movq %r14, %rdi
callq 0x5b2b
cmpq 0x10(%rax), %r15
setle %bpl
jg 0x4274
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %r14
cmpl $0x1, (%rax)
jne 0x4243
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x70c3
movq %r15, %rdi
movq %r14, %rsi
callq 0x156f
movq %r14, %rdi
callq 0x1539
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x2, %rax
jl 0x435c
movq %r14, %rdi
callq 0x5a98
testq %rax, %rax
jle 0x42ec
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x5acc
cmpl $0x4, (%rax)
jne 0x4351
incq %r15
movq %r14, %rdi
callq 0x5a98
cmpq %r15, %rax
jg 0x42cc
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movb $0x1, %bpl
cmpl $0x1, (%rax)
je 0x433b
movq %rax, %r14
movq 0x10(%r15), %r15
movq %r14, %rdi
callq 0x5b2b
cmpq 0x10(%rax), %r15
setge %bpl
jl 0x433b
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %r14
cmpl $0x1, (%rax)
jne 0x430a
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x70c3
movq %r15, %rdi
movq %r14, %rsi
callq 0x1602
movq %r14, %rdi
callq 0x15cc
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x2, %rax
jl 0x43f2
movq %r14, %rdi
callq 0x5a98
testq %rax, %rax
jle 0x43ad
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x5acc
cmpl $0x4, (%rax)
jne 0x43e7
incq %r15
movq %r14, %rdi
callq 0x5a98
cmpq %r15, %rax
jg 0x438d
cmpl $0x1, (%r14)
jne 0x43b8
xorl %r15d, %r15d
jmp 0x43d7
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x5b2b
addq 0x10(%rax), %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %r14
cmpl $0x1, (%rax)
jne 0x43bb
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7131
movq %r15, %rdi
movq %r14, %rsi
callq 0x1695
movq %r14, %rdi
callq 0x165f
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_mul
struct value*
builtin_mul(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_GTE("*", args, 2);
    ASSERT_TYPE_ALL("*", args, VALUE_NUMBER);

    long res = 1;
    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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x5a98
cmpq $0x2, %rax
jl 0x4486
movq %rbx, %rdi
callq 0x5a98
testq %rax, %rax
jle 0x4443
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5acc
cmpl $0x4, (%rax)
jne 0x447b
incq %r15
movq %rbx, %rdi
callq 0x5a98
cmpq %r15, %rax
jg 0x4423
movl $0x1, %r15d
cmpl $0x1, (%rbx)
je 0x446b
movq %rbx, %rdi
callq 0x5b2b
imulq 0x10(%rax), %r15
movq %rbx, %rdi
callq 0x5abc
movq %rax, %rbx
cmpl $0x1, (%rax)
jne 0x444e
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7131
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1728
movq %rbx, %rdi
callq 0x16f2
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_sub
struct value*
builtin_sub(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_GTE("-", args, 2);
    ASSERT_TYPE_ALL("-", args, VALUE_NUMBER);

    long res = CAR(args)->as.number;
    args = CDR(args);

    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 %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x2, %rax
jl 0x452e
movq %r14, %rdi
callq 0x5a98
testq %rax, %rax
jle 0x44db
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x5acc
cmpl $0x4, (%rax)
jne 0x4523
incq %r15
movq %r14, %rdi
callq 0x5a98
cmpq %r15, %rax
jg 0x44bb
movq %r14, %rdi
callq 0x5b2b
movq 0x10(%rax), %r15
movq %r14, %rdi
callq 0x5abc
cmpl $0x1, (%rax)
je 0x4513
movq %rax, %r14
movq %r14, %rdi
callq 0x5b2b
subq 0x10(%rax), %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %r14
cmpl $0x1, (%rax)
jne 0x44f7
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7131
movq %r15, %rdi
movq %r14, %rsi
callq 0x17bb
movq %r14, %rdi
callq 0x1785
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_div
struct value*
builtin_div(struct vm* vm, struct value* args)
{
    ASSERT_ARITY_GTE("/", args, 2);
    ASSERT_TYPE_ALL("/", args, VALUE_NUMBER);

    long res = CAR(args)->as.number;
    args = CDR(args);

    while (!value_is_empty_list(args)) {
        if (CAR(args)->as.number == 0) {
            fprintf(stderr, "error: divide by zero\n");
            exit(EXIT_FAILURE);
        }

        res /= CAR(args)->as.number;
        args = CDR(args);
    }

    return vm_make_number(vm, res);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x2, %rax
jl 0x45f5
movq %r14, %rdi
callq 0x5a98
testq %rax, %rax
jle 0x4583
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x5acc
cmpl $0x4, (%rax)
jne 0x45e5
incq %r15
movq %r14, %rdi
callq 0x5a98
cmpq %r15, %rax
jg 0x4563
movq %r14, %rdi
callq 0x5b2b
movq 0x10(%rax), %r15
movq %r14, %rdi
callq 0x5abc
cmpl $0x1, (%rax)
je 0x45d5
movq %rax, %r14
movq %r14, %rdi
callq 0x5b2b
cmpq $0x0, 0x10(%rax)
je 0x45f0
movq %r14, %rdi
callq 0x5b2b
movq %rax, %rcx
movq %r15, %rax
cqto
idivq 0x10(%rcx)
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %r14
cmpl $0x1, (%rax)
jne 0x459f
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7131
movq %r15, %rdi
movq %r14, %rsi
callq 0x184e
callq 0x18ab
movq %r14, %rdi
callq 0x1818
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/builtin.c
// Function: builtin_cons
struct value*
builtin_cons(struct vm* vm, struct value* args)
{
    ASSERT_ARITY("cons", args, 2);

    struct value* a = CAR(args);
    struct value* b = CADR(args);
    return vm_make_pair(vm, a, b);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5a98
cmpq $0x2, %rax
jne 0x46be
movq %r14, %rdi
callq 0x5b2b
movq %rax, %r15
movq %r14, %rdi
callq 0x5abc
movq %rax, %rdi
callq 0x5b2b
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x7232
movq %r14, %rdi
callq 0x1942