LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/richarddurbin[P]hash10x/fq2b.c
// Function: seqPack
void seqPack (char *s, U32 *u, int len) /* compress s into (len+)/4 U32  */
{
  assert (isPackInitialised) ;
  int i ;
  while (len > 16)
    { *u = 0 ; for (i = 0 ; i < 16 ; ++i) *u = (*u << 2) | sPack[*s++] ;
      len -= 16 ; ++u ;
    }
  *u = 0 ; for (i = 0 ; i < len ; ++i) *u = (*u << 2) | sPack[*s++] ;
}

// Assembly:
pushq %rax
cmpb $0x1, 0x5a75(%rip)      # 0x7130
jne 0x1741
cmpl $0x11, %edx
jl 0x170e
leaq 0x5a73(%rip), %rax      # 0x7140
movq %rdi, %rcx
movl $0x0, (%rsi)
xorl %r8d, %r8d
xorl %edi, %edi
shll $0x2, %edi
movsbq (%rcx,%r8), %r9
orl (%rax,%r9,4), %edi
movl %edi, (%rsi)
incq %r8
cmpl $0x10, %r8d
jne 0x16db
leal -0x10(%rdx), %r9d
addq $0x4, %rsi
leaq (%rcx,%r8), %rdi
cmpl $0x20, %edx
movl %r9d, %edx
jg 0x16cd
addq %r8, %rcx
movq %rcx, %rdi
jmp 0x1711
movl %edx, %r9d
movl $0x0, (%rsi)
testl %r9d, %r9d
jle 0x173f
movl (%rsi), %eax
movl %r9d, %ecx
xorl %edx, %edx
leaq 0x5a16(%rip), %r8       # 0x7140
shll $0x2, %eax
movsbq (%rdi,%rdx), %r9
orl (%r8,%r9,4), %eax
movl %eax, (%rsi)
incq %rdx
cmpl %edx, %ecx
jne 0x172a
popq %rax
retq
leaq 0x28e8(%rip), %rdi      # 0x4030
leaq 0x28f3(%rip), %rsi      # 0x4042
leaq 0x28f3(%rip), %rcx      # 0x4049
movl $0x23, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/richarddurbin[P]hash10x/fq2b.c
// Function: qualPack
void qualPack (char *q, U32 *u, int len)
{
  assert (isPackInitialised) ;
  int i ;
  while (len > 32)
    { *u = 0 ; for (i = 0 ; i < 32 ; ++i) *u = (*u << 1) | qPack[*q++] ;
      len -= 32 ; ++u ;
    }
  *u = 0 ; for (i = 0 ; i < len ; ++i) *u = (*u << 1) | qPack[*q++] ;
}

// Assembly:
pushq %rax
cmpb $0x1, 0x5982(%rip)      # 0x7130
jne 0x182e
cmpl $0x21, %edx
jl 0x17fc
leaq 0x5d84(%rip), %rax      # 0x7540
movq %rdi, %rcx
movl $0x0, (%rsi)
xorl %r8d, %r8d
xorl %edi, %edi
addl %edi, %edi
movsbq (%rcx,%r8), %r9
orl (%rax,%r9,4), %edi
movl %edi, (%rsi)
incq %r8
cmpl $0x20, %r8d
jne 0x17ca
leal -0x20(%rdx), %r9d
addq $0x4, %rsi
leaq (%rcx,%r8), %rdi
cmpl $0x40, %edx
movl %r9d, %edx
jg 0x17bc
addq %r8, %rcx
movq %rcx, %rdi
jmp 0x17ff
movl %edx, %r9d
movl $0x0, (%rsi)
testl %r9d, %r9d
jle 0x182c
movl (%rsi), %eax
movl %r9d, %ecx
xorl %edx, %edx
leaq 0x5d28(%rip), %r8       # 0x7540
addl %eax, %eax
movsbq (%rdi,%rdx), %r9
orl (%r8,%r9,4), %eax
movl %eax, (%rsi)
incq %rdx
cmpl %edx, %ecx
jne 0x1818
popq %rax
retq
leaq 0x27fb(%rip), %rdi      # 0x4030
leaq 0x2806(%rip), %rsi      # 0x4042
leaq 0x2827(%rip), %rcx      # 0x406a
movl $0x36, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/richarddurbin[P]hash10x/fq2b.c
// Function: find10xBarcode
BOOL find10xBarcode (U32* u)
{
  if (!table[*u]) { ++nBad ; return FALSE ; }
  U32 v = switchBase (*u, table[*u]) ;
  if (v != *u) { ++nFixed ; ++nFixBase[15 - (table[*u]-1)/4] ; *u = v ; }
  return TRUE ;
}

// Assembly:
movq 0x6104(%rip), %rax      # 0x7958
movl (%rdi), %esi
movzbl (%rax,%rsi), %edx
testq %rdx, %rdx
je 0x18a4
leaq 0x60fa(%rip), %rax      # 0x7960
movl -0x4(%rax,%rdx,4), %ecx
andl %esi, %ecx
leaq 0x61ed(%rip), %rax      # 0x7a60
orl -0x4(%rax,%rdx,4), %ecx
movb $0x1, %al
cmpl %esi, %ecx
je 0x18a3
decq %rdx
incl 0x62de(%rip)            # 0x7b64
leal 0x3(%rdx), %esi
testl %edx, %edx
cmovnsl %edx, %esi
sarl $0x2, %esi
negl %esi
movslq %esi, %rdx
leaq 0x62d3(%rip), %rsi      # 0x7b70
incl 0x3c(%rsi,%rdx,4)
movl %ecx, (%rdi)
retq
incl 0x62b6(%rip)            # 0x7b60
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/TimeToogo[P]ff-proxy/client/c/client.c
// Function: ff_client_read_payload_from_file
void ff_client_read_payload_from_file(struct ff_request *request, FILE *fd)
{
    uint8_t buffer[1024];
    uint16_t payload_length = 0;
    uint16_t chunk_length = 0;

    struct ff_request_payload_node *payload = ff_request_payload_node_alloc();
    payload->value = malloc(sizeof(buffer));

    while ((chunk_length = fread(buffer, 1, sizeof(buffer), fd)) != 0)
    {
        payload_length += chunk_length;
        payload->value = realloc(payload->value, payload_length);

        if (payload->value == NULL)
        {
            ff_log(FF_FATAL, "Could not reallocate payload buffer");
            exit(1);
        }

        memcpy(payload->value, buffer, chunk_length);
    }

    ff_log(FF_DEBUG, "Read %u bytes from STDIN", payload_length);

    payload->length = payload_length;
    ff_client_request_add_payload(request, payload);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
callq 0x3e15
movq %rax, %r14
movl $0x400, %edi            # imm = 0x400
callq 0x2220
movq %rax, 0x8(%r14)
leaq -0x430(%rbp), %rdi
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
movq %r15, %rcx
callq 0x2260
movq %rax, %r13
xorl %ebx, %ebx
testw %r13w, %r13w
je 0x2808
leaq -0x430(%rbp), %r12
addl %r13d, %ebx
movq 0x8(%r14), %rdi
movzwl %bx, %esi
callq 0x22a0
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x285f
movzwl %r13w, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2150
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
movq %r12, %rdi
movq %r15, %rcx
callq 0x2260
movq %rax, %r13
testw %r13w, %r13w
jne 0x27bf
movzwl %bx, %r15d
leaq 0x2897(%rip), %rsi      # 0x50aa
movl $0x1, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x3c64
movw %r15w, 0x2(%r14)
movq -0x30(%rbp), %rdx
movq 0x50(%rdx), %rax
testq %rax, %rax
je 0x2845
movq %r14, 0x10(%rax)
movzwl 0x2(%rax), %ecx
addw (%rax), %cx
movw %cx, (%r14)
jmp 0x2849
movq %r14, 0x50(%rdx)
addq %r15, 0x40(%rdx)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2820(%rip), %rsi      # 0x5086
movl $0x5, %edi
xorl %eax, %eax
callq 0x3c64
movl $0x1, %edi
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O1/TimeToogo[P]ff-proxy/client/c/client.c
// Function: ff_client_write_options
uint32_t ff_client_write_options(void *buffer, struct ff_request_option_node **options, uint8_t amount)
{
    uint32_t buff_i = 0;

    for (uint8_t i = 0; i < amount; i++)
    {
        struct __raw_ff_request_option_header *option_header = (struct __raw_ff_request_option_header *)(buffer + buff_i);
        option_header->type = options[i]->type;
        option_header->length = htons(options[i]->length);
        buff_i += sizeof(struct __raw_ff_request_option_header);
        memcpy(buffer + buff_i, options[i]->value, options[i]->length);
        buff_i += options[i]->length;
    }

    return buff_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
je 0x2d7f
movq %rsi, %rbx
movq %rdi, %r14
movzbl %dl, %r12d
xorl %r13d, %r13d
xorl %r15d, %r15d
movl %r15d, %eax
movq (%rbx,%r13,8), %rcx
movb (%rcx), %dl
movb %dl, (%r14,%rax)
movzwl 0x4(%rcx), %edx
movl %edx, %esi
rolw $0x8, %si
movw %si, 0x1(%r14,%rax)
leal 0x3(%r15), %edi
addq %r14, %rdi
movq 0x8(%rcx), %rsi
callq 0x2150
movq (%rbx,%r13,8), %rax
movzwl 0x4(%rax), %eax
addl %eax, %r15d
addl $0x3, %r15d
incq %r13
cmpq %r13, %r12
jne 0x2d39
jmp 0x2d82
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/TimeToogo[P]ff-proxy/client/c/client.c
// Function: ff_client_calculate_request_size
uint32_t ff_client_calculate_request_size(struct ff_request *request)
{
    uint32_t length = 0;

    length += sizeof(struct __raw_ff_request_header);

    for (int i = 0; i < request->options_length; i++)
    {
        length += sizeof(struct __raw_ff_request_option_header);
        length += request->options[i]->length;
    }

    length += request->payload_length;

    return length;
}

// Assembly:
movzbl 0x28(%rdi), %ecx
testq %rcx, %rcx
je 0x2df1
pushq %rbp
movq %rsp, %rbp
movq 0x30(%rdi), %rdx
movl $0x14, %eax
xorl %esi, %esi
movq (%rdx,%rsi,8), %r8
movzwl 0x4(%r8), %r8d
addl %r8d, %eax
addl $0x3, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x2dd7
popq %rbp
jmp 0x2df6
movl $0x14, %eax
addl 0x40(%rdi), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/TimeToogo[P]ff-proxy/client/c/client.c
// Function: ff_client_generate_request_id
uint64_t ff_client_generate_request_id()
{
    uint8_t buffer[8];

    if (!RAND_bytes(buffer, sizeof(buffer)))
    {
        ff_log(FF_FATAL, "Failed to generate request ID");
        exit(EXIT_FAILURE);
    }

    return (uint64_t)(
        (uint64_t)buffer[0] | ((uint64_t)buffer[1] << 8) | ((uint64_t)buffer[2] << 16) | ((uint64_t)buffer[3] << 24) | ((uint64_t)buffer[4] << 32) | ((uint64_t)buffer[5] << 40) | ((uint64_t)buffer[6] << 48) | ((uint64_t)buffer[7] << 56));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x2240
testl %eax, %eax
je 0x2e1e
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
leaq 0x22c1(%rip), %rsi      # 0x50e6
movl $0x5, %edi
xorl %eax, %eax
callq 0x3c64
movl $0x1, %edi
callq 0x21e0
nop
// File: /workspace/github_c_makefile_star2_O1/TimeToogo[P]ff-proxy/client/c/main.c
// Function: main
int main(int argc, char **argv)
{
    enum ff_client_action action = ff_client_parse_arguments(&ff_global_config, argc, argv);
    int ret = EXIT_SUCCESS;

    switch (action)
    {
    case FF_CLIENT_ACTION_MAKE_REQUEST:
        ret = ff_client_make_request(&ff_global_config, stdin);
        break;

    case FF_CLIENT_ACTION_PRINT_VERSION:
        ff_print_version(stdout);
        ret = 0;
        break;

    case FF_CLIENT_ACTION_PRINT_USAGE:
        ff_client_print_usage(stdout);
        ret = 0;
        break;

    case FF_CLIENT_ACTION_INVALID_ARGS:
        ff_client_print_usage(stderr);
        ret = EXIT_FAILURE;
        break;
    }

    ff_log(FF_INFO, "Exiting...");
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rdx
movl %edi, %esi
leaq 0x4ae2(%rip), %rdi      # 0x81a8
callq 0x2e3c
xorl %ebx, %ebx
decl %eax
cmpl $0x3, %eax
ja 0x3734
leaq 0x1f8d(%rip), %rcx      # 0x5668
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x48ed(%rip), %rax      # 0x7fd8
movq (%rax), %rsi
leaq 0x4ab3(%rip), %rdi      # 0x81a8
callq 0x244c
movl %eax, %ebx
jmp 0x3734
movq 0x48bb(%rip), %rax      # 0x7fc0
movq (%rax), %rdi
callq 0x319f
jmp 0x3734
movq 0x48ca(%rip), %rax      # 0x7fe0
movq (%rax), %rdi
callq 0x319f
movl $0x1, %ebx
jmp 0x3734
movq 0x4894(%rip), %rax      # 0x7fc0
movq (%rax), %rdi
callq 0x3c19
leaq 0x1f3d(%rip), %rsi      # 0x5678
movl $0x2, %edi
xorl %eax, %eax
callq 0x3c64
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/cli.c
// Function: cli_display
extern void cli_display(cli_s *p)
{
	CLI_DO_INIT;

#ifndef _WIN32
	cli_sigwinch(SIGWINCH);
#endif
	cli_size_width = 0;

	cli_bps_s bps[BPS];
	memset(bps, 0x00, BPS * sizeof( cli_bps_s ));
	int b = 0;

	fprintf(stderr, "\e[?25l\n"); /* hide cursor */
	while (*p->status == CLI_INIT || *p->status == CLI_RUN)
	{
		struct timespec s = { 0, 10 * MILLION }; /* 10 milliseconds */
		nanosleep(&s, NULL);
		if (*p->status == CLI_INIT)
			continue;
		struct timeval tv;
		gettimeofday(&tv, NULL);
		bps[b].time = tv.tv_sec * MILLION + tv.tv_usec;
		bps[b].bytes = p->current->offset;
		b++;
		if (b >= BPS)
			b = 0;
		cli_display_bars(p->total, p->current, bps);
	}
	if (*p->status == CLI_DONE)
	{
		p->total->offset = p->total->size;
		p->current->offset = p->current->size;
		cli_display_bars(p->total, p->current, bps);
	}
	fprintf(stderr, "\e[?25h\n"); /* restore cursor */

	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %rdi, %rbx
cmpb $0x0, 0x5d05(%rip)      # 0x8258
jne 0x255a
callq 0x3a95
xorl %r13d, %r13d
pushq $0x1
popq %rdi
leaq 0x20(%rsp), %r14
movl $0x5413, %esi           # imm = 0x5413
movq %r14, %rdx
xorl %eax, %eax
callq 0x2190
movzwl 0x2(%r14), %eax
movl %eax, 0x5c81(%rip)      # 0x8200
leaq 0x1c03(%rip), %rsi      # 0x4189
pushq $0x1c
popq %rdi
callq 0x2200
leaq 0x20(%rsp), %rdi
movl $0x800, %edx            # imm = 0x800
xorl %esi, %esi
callq 0x2180
movq 0x5a52(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x2de3(%rip), %rdi      # 0x5393
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x2360
leaq 0x10(%rsp), %r15
movq %rsp, %r12
xorl %ebp, %ebp
movq (%rbx), %rax
movl (%rax), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x263a
movups 0x2d07(%rip), %xmm0     # 0x52e0
movaps %xmm0, 0x10(%rsp)
movq %r15, %rdi
xorl %esi, %esi
callq 0x2150
movq (%rbx), %rax
cmpl $0x1, (%rax)
je 0x25c5
movq %r12, %rdi
xorl %esi, %esi
callq 0x2160
imulq $0xf4240, (%rsp), %rax  # imm = 0xF4240
addq 0x8(%rsp), %rax
movslq %ebp, %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
movq %rax, 0x20(%rsp,%rdx)
movq 0x8(%rbx), %rsi
movq (%rsi), %rax
movq %rax, 0x28(%rsp,%rdx)
leal 0x1(%rcx), %ebp
cmpl $0x7f, %ecx
cmovgel %r13d, %ebp
movq 0x10(%rbx), %rdi
movq %r14, %rdx
callq 0x41c8
jmp 0x25c5
testl %eax, %eax
jne 0x265e
movq 0x10(%rbx), %rdi
movq 0x8(%rdi), %rax
movq %rax, (%rdi)
movq 0x8(%rbx), %rsi
movq 0x8(%rsi), %rax
movq %rax, (%rsi)
leaq 0x20(%rsp), %rdx
callq 0x41c8
movq 0x5993(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x2c01(%rip), %rdi      # 0x5270
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x2360
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/cli.c
// Function: cli_display_bar
static void cli_display_bar(char *name, cli_progress_s *p, double percent)
{
	int name_width = CLI_TRUNCATED_DISPLAY_SHORT + strlen(CLI_TRUNCATED_ELLIPSE) + (cli_width > CLI_DEFAULT ? CLI_TRUNCATED_DISPLAY_SHORT : 0);
	fprintf(stderr, "\r%-*s : ", name_width, name);
	if (cli_width > CLI_SMALL)
		fprintf(stderr, "%'13" PRIu64 "/%-'13" PRIu64 " (", p->offset, p->size);
	fprintf(stderr, "%3.0f%%", isnan(percent) ? 0.0f : (percent > PERCENT ? PERCENT : percent));
	if (cli_width > CLI_SMALL)
		fprintf(stderr, ")");

	if (cli_width > CLI_DEFAULT)
	{
		int progress_bar_width = cli_width - CLI_LARGE;
		fprintf(stderr, " [");
		/*
		 * display overall progress bar
		 */
		for (int i = 0; i < progress_bar_width; i++)
			fprintf(stderr, "%c", i < progress_bar_width * percent  / PERCENT ? '=' : ' ');
		fprintf(stderr, "]");
	}
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %rcx
cmpl $0x51, 0x5b57(%rip)     # 0x8200
pushq $0x18
popq %rax
pushq $0xe
popq %rdx
cmovgel %eax, %edx
movq 0x593f(%rip), %r14      # 0x7ff8
movq (%r14), %rdi
leaq 0x2cf2(%rip), %rsi      # 0x53b5
xorl %eax, %eax
callq 0x2220
cmpl $0x3f, 0x5b2f(%rip)     # 0x8200
jl 0x26eb
movq (%r14), %rdi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
leaq 0x2cda(%rip), %rsi      # 0x53be
xorl %eax, %eax
callq 0x2220
movq (%r14), %rdi
movsd 0x2c0a(%rip), %xmm1     # 0x5300
movsd 0x8(%rsp), %xmm0
minsd %xmm0, %xmm1
cmpunordsd %xmm0, %xmm0
andnpd %xmm1, %xmm0
leaq 0x2cbf(%rip), %rsi      # 0x53cf
movb $0x1, %al
callq 0x2220
cmpl $0x3f, 0x5ae2(%rip)     # 0x8200
jl 0x272b
movq (%r14), %rsi
pushq $0x29
popq %rdi
callq 0x21b0
movl 0x5acf(%rip), %ebx      # 0x8200
cmpl $0x51, %ebx
jge 0x2741
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addl $-0x4b, %ebx
movq (%r14), %rcx
leaq 0x2b6e(%rip), %rdi      # 0x52bc
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x2360
cvtsi2sd %ebx, %xmm0
mulsd 0x8(%rsp), %xmm0
divsd 0x2b95(%rip), %xmm0     # 0x5300
movsd %xmm0, 0x10(%rsp)
xorpd %xmm1, %xmm1
pushq $0x3d
popq %rbp
pushq $0x20
popq %r15
movsd %xmm1, 0x8(%rsp)
movq (%r14), %rsi
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movl %r15d, %edi
cmoval %ebp, %edi
callq 0x21b0
movsd 0x8(%rsp), %xmm1
addsd 0x2b60(%rip), %xmm1     # 0x5308
decl %ebx
jne 0x277c
movq (%r14), %rsi
pushq $0x5d
popq %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/src/hide.c
// Function: progress_current_update
static void progress_current_update(uint64_t i, uint64_t j)
{
	if (i < j && i > 0)
	{
		ui.current->offset = i;
		ui.current->size = j;
	}
	return;
}

// Assembly:
cmpq %rsi, %rdi
setae %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x2fbd
movq 0x526a(%rip), %rax      # 0x8220
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/error.c
// Function: error_init
extern void error_init(void)
{
	if (error_inited)
		return;

	signal(SIGILL,  on_error);
	signal(SIGSEGV, on_error);
	signal(SIGBUS,  on_error);
	signal(SIGABRT, on_error);
	signal(SIGSYS,  on_error);
	//signal(SIGPROF, on_error);

	error_inited = 1;

	return;
}

// Assembly:
cmpl $0x0, 0x4a78(%rip)      # 0x8234
je 0x37bf
retq
pushq %rbx
leaq -0x1c7(%rip), %rbx      # 0x3600
movl $0x4, %edi
movq %rbx, %rsi
callq 0x2200
movl $0xb, %edi
movq %rbx, %rsi
callq 0x2200
movl $0x7, %edi
movq %rbx, %rsi
callq 0x2200
movl $0x6, %edi
movq %rbx, %rsi
callq 0x2200
movl $0x1f, %edi
movq %rbx, %rsi
callq 0x2200
movl $0x1, 0x4a22(%rip)      # 0x8234
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/error.c
// Function: die
extern void die(const char * const restrict s, ...)
{
	int ex = errno;
	char *d = NULL;
	va_list ap;
	va_start(ap, s);
#ifndef _WIN32
	vasprintf(&d, s, ap);
#else
	uint8_t l = 0xFF;
	if ((d = calloc(l, sizeof l)))
		vsnprintf(d, l - 1, s, ap);
#endif
	fprintf(stderr, "%s", d);
	va_end(ap);
	fprintf(stderr, "\n");
#ifdef BUILD_GUI
	error_gui_alert(d);
#endif
	free(d);
	if (ex)
	{
		char * const restrict e = strdup(strerror(ex));
		for (uint32_t i = 0; e && i < strlen(e); i++)
			e[i] = tolower((unsigned char)e[i]);
		fprintf(stderr, "%s\n", e);
		free(e);
#if !defined _WIN32 && !defined __CYGWIN__ && !defined __FreeBSD__
		void *bt[BACKTRACE_BUFFER_LIMIT];
		int c = backtrace(bt, BACKTRACE_BUFFER_LIMIT);
		char **sym = backtrace_symbols(bt, c);
		if (sym)
		{
			for (int i = 0; i < c; i++)
				fprintf(stderr, "%s\n", sym[i]);
			free(sym);
		}
#endif
	}
	exit(ex);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20e8, %rsp           # imm = 0x20E8
movq %rdi, %r14
leaq 0x30(%rsp), %r12
movq %rsi, 0x8(%r12)
movq %rdx, 0x10(%r12)
movq %rcx, 0x18(%r12)
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0x3884
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
callq 0x2060
movl (%rax), %ebx
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
leaq 0x10(%rsp), %rdx
movq %r12, 0x10(%rdx)
leaq 0x2120(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x20f0
movq 0x472d(%rip), %r12      # 0x7ff8
movq (%r12), %rsi
movq (%r15), %rdi
callq 0x2170
movq (%r12), %rsi
movl $0xa, %edi
callq 0x21b0
movq (%r15), %rdi
callq 0x2050
testl %ebx, %ebx
je 0x39b3
movl %ebx, %edi
callq 0x2390
movq %rax, %rdi
callq 0x2380
movq %rax, %r14
testq %rax, %rax
je 0x393b
xorl %ecx, %ecx
movl %ecx, %r15d
movq %r14, %rdi
callq 0x2100
cmpq %r15, %rax
jbe 0x393b
callq 0x23d0
leal 0x1(%r15), %ecx
movq (%rax), %rax
movzbl (%r14,%r15), %edx
movb (%rax,%rdx,4), %al
movb %al, (%r14,%r15)
testq %r14, %r14
jne 0x390e
movq (%r12), %rdi
leaq 0x1a2b(%rip), %rsi      # 0x5371
movq %r14, %rdx
xorl %eax, %eax
callq 0x2220
movq %r14, %rdi
callq 0x2050
leaq 0xe0(%rsp), %r14
movq %r14, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x2110
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
callq 0x20d0
testq %rax, %rax
je 0x39b3
movq %rax, %r14
testl %ebp, %ebp
jle 0x39ab
movl %ebp, %r13d
leaq 0x19e2(%rip), %r15      # 0x5371
xorl %ebp, %ebp
movq (%r12), %rdi
movq (%r14,%rbp,8), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x2220
incq %rbp
cmpq %rbp, %r13
jne 0x3991
movq %r14, %rdi
callq 0x2050
movl %ebx, %edi
callq 0x2350
nop
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/cli.c
// Function: cli_printf
extern int cli_printf(const char * const restrict s, ...)
{
	CLI_DO_INIT;

	va_list ap;
	va_start(ap, s);
	char *d = NULL;
	vasprintf(&d, s, ap);
	int x = cli_print(stdout, d);
	va_end(ap);
	free(d);
	return x;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
testb %al, %al
je 0x3a07
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
cmpb $0x0, 0x4831(%rip)      # 0x8258
jne 0x3a2e
callq 0x3a95
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq 0x4565(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
movq (%r14), %rsi
callq 0x3ae7
movl %eax, %ebx
movq (%r14), %rdi
callq 0x2050
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/cli.c
// Function: cli_print
static int cli_print(FILE *stream, const char *text)
{
	size_t l = strlen(text);
	char *copy = m_calloc(1, l + 1);
#ifndef _WIN32
	bool strip = !((stream == stdout && isatty(STDOUT_FILENO)) || (stream == stderr && isatty(STDERR_FILENO)));
#else
	#ifdef __DEBUG__
	bool strip = cli_inited != 1;
	#else
	bool strip = false;
	#endif
#endif
	if (strip)
	{
		char *ptr = (char *)text;
		for (size_t i = 0, j = 0; i < l; i++)
		{
			char *e = strstr(ptr, "\x1b[");
			if (!e)
				break;
			memcpy(copy + j, ptr, e - ptr);
			j += e - ptr;
			ptr = strchr(e, 'm') + 1;
		}
		strcat(copy, ptr);
	}
	else
		strcpy(copy, text);
	int x = fprintf(stream, "%s", copy);
	//fprintf(stream, "\n");
	free(copy);
	return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2100
movq %rax, %r12
leaq 0x1(%rax), %r8
leaq 0x1867(%rip), %rdi      # 0x5375
leaq 0x1922(%rip), %rdx      # 0x5437
movl $0x1, %ecx
movl $0x16a, %esi            # imm = 0x16A
callq 0x436b
movq %rax, %r14
movq 0x44aa(%rip), %rax      # 0x7fd8
cmpq %rbx, (%rax)
je 0x3bb9
movq 0x44ba(%rip), %rax      # 0x7ff8
cmpq %rbx, (%rax)
je 0x3bcc
movq %rbx, (%rsp)
testq %r12, %r12
je 0x3ba8
decq %r12
xorl %r13d, %r13d
movq %r15, %rdi
leaq 0x18e1(%rip), %rsi      # 0x5441
callq 0x23c0
movq %rax, %rbx
testq %rax, %rax
je 0x3b98
leaq (%r14,%r13), %rdi
movq %rbx, %rbp
subq %r15, %rbp
movq %r15, %rsi
movq %rbp, %rdx
callq 0x2230
addq %rbp, %r13
movq %rbx, %rdi
movl $0x6d, %esi
callq 0x2130
movq %rax, %r15
incq %r15
subq $0x1, %r12
setb %al
testq %rbx, %rbx
je 0x3ba8
testb %al, %al
je 0x3b56
movq %r14, %rdi
movq %r15, %rsi
callq 0x2330
movq (%rsp), %rbx
jmp 0x3be9
movl $0x1, %edi
callq 0x20c0
testl %eax, %eax
jne 0x3bde
jmp 0x3b37
movl $0x2, %edi
callq 0x20c0
testl %eax, %eax
je 0x3b47
movq %r14, %rdi
movq %r15, %rsi
callq 0x20a0
leaq 0x15d4(%rip), %rsi      # 0x51c4
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2220
movl %eax, %ebx
movq %r14, %rdi
callq 0x2050
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/cli.c
// Function: cli_eprintf
extern int cli_eprintf(const char * const restrict s, ...)
{
	CLI_DO_INIT;

	va_list ap;
	va_start(ap, s);
	char *d = NULL;
	vasprintf(&d, s, ap);
	int x = cli_print(stderr, d);
	va_end(ap);
	free(d);
	return x;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
testb %al, %al
je 0x3c63
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
cmpb $0x0, 0x45d5(%rip)      # 0x8258
jne 0x3c8a
callq 0x3a95
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq 0x4329(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq (%r14), %rsi
callq 0x3ae7
movl %eax, %ebx
movq (%r14), %rdi
callq 0x2050
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/cli.c
// Function: logger
extern int logger(const char * const restrict s, ...)
{
	CLI_DO_INIT;

	int x = 0;
#if 0
	time_t now = time(NULL);
	char at[24];
	struct tm t;
	localtime_r(&now, &t);
	strftime(at, sizeof at, "%F %T : ", &t);
	x += cli_print(stderr, at);
#endif
	va_list ap;
	va_start(ap, s);
	char *d = NULL;
	vasprintf(&d, s, ap);
	x += cli_print(stderr, d);
	va_end(ap);
	free(d);

	static const char nl[] = "\n";
	x += cli_print(stderr, nl);

	return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
testb %al, %al
je 0x3d3e
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
cmpb $0x0, 0x44fa(%rip)      # 0x8258
jne 0x3d65
callq 0x3a95
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq 0x424e(%rip), %r15      # 0x7ff8
movq (%r15), %rdi
movq (%r14), %rsi
callq 0x3ae7
movl %eax, %ebx
movq (%r14), %rdi
callq 0x2050
movq (%r15), %rdi
leaq 0x159b(%rip), %rsi      # 0x5364
callq 0x3ae7
addl %ebx, %eax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/cli.c
// Function: cli_fprintf
extern int cli_fprintf(FILE *f, const char * const restrict s, ...)
{
	CLI_DO_INIT;

	va_list ap;
	va_start(ap, s);
	char *d = NULL;
	vasprintf(&d, s, ap);
	int x = cli_print(f, d);
	va_end(ap);
	free(d);
	return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testb %al, %al
je 0x3e2d
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
cmpb $0x0, 0x4410(%rip)      # 0x8258
jne 0x3e4f
callq 0x3a95
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x20f0
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x3ae7
movl %eax, %ebx
movq (%r15), %rdi
callq 0x2050
movl %ebx, %eax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/cli.c
// Function: cli_fprintx
extern int cli_fprintx(FILE *f, const uint8_t * const restrict x, size_t z)
{
	CLI_DO_INIT;

#define CLI_PRINTX_W 16
	// TODO allow variable width lines
	int l = 0, o = 0;
	char r[CLI_PRINTX_W * 2 + CLI_PRINTX_W] = { 0x0 };
	for (size_t i = 0; i < z; i++)
	{
		char c[4] = { 0x0 };
		sprintf(c, "%02x", x[i]);
		strcat(r, c);
		if (i % 2 == 1)
			strcat(r, " ");
		if (i % CLI_PRINTX_W == (CLI_PRINTX_W - 1))
		{
			l += cli_fprintf(f, "%08x: %s\n", o, r);
			memset(r, 0x00, sizeof r);
			o += CLI_PRINTX_W;
		}
	}
	if (strlen(r))
		l += cli_fprintf(f, "%08x: %s\n", o, r);
	return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
cmpb $0x0, 0x4351(%rip)      # 0x8258
jne 0x3f0e
callq 0x3a95
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
testq %r14, %r14
je 0x3fc6
leaq 0xc(%rsp), %rbx
leaq 0x20(%rsp), %r13
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %ebp, %ebp
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax,%r15), %edx
movq %rbx, %rdi
leaq 0x140f(%rip), %rsi      # 0x5366
xorl %eax, %eax
callq 0x2340
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2330
testb $0x1, %r15b
je 0x3f7e
movq %r13, %rdi
callq 0x2100
movw $0x20, 0x20(%rsp,%rax)
movl %r15d, %eax
notl %eax
testb $0xf, %al
jne 0x3fb8
movq 0x10(%rsp), %rdi
leaq 0x13d8(%rip), %rsi      # 0x536b
movl %r12d, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x3ddd
addl %eax, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
addl $0x10, %r12d
incq %r15
cmpq %r15, %r14
jne 0x3f3b
jmp 0x3fcb
xorl %ebp, %ebp
xorl %r12d, %r12d
cmpb $0x0, 0x20(%rsp)
je 0x3fef
leaq 0x1392(%rip), %rsi      # 0x536b
leaq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x3ddd
addl %eax, %ebp
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/cli.c
// Function: cli_calc_bps
extern double cli_calc_bps(cli_bps_s *bps)
{
	CLI_DO_INIT;

	cli_bps_s *copy = m_calloc(BPS, sizeof( cli_bps_s ));
	for (int i = 0; i < BPS; i++)
	{
		copy[i].time  = bps[i].time;
		copy[i].bytes = bps[i].bytes;
	}
	qsort(copy, BPS, sizeof( cli_bps_s ), cli_bps_sort);
	double avg[BPS - 1] = { 0.0f };
	for (int i = 0; i < BPS - 1; i++)
		/*
		 * requires scale factor of MILLION as time is in microseconds
		 * not seconds (millions of bytes / micros of seconds, so to
		 * speak)
		 */
		avg[i] = MILLION * (double)(copy[i + 1].bytes - copy[i].bytes) / (double)(copy[i + 1].time - copy[i].time);
	double val = 0.0;
	for (int i = 0; i < BPS - 1; i++)
		val += avg[i];
	free(copy);
	return val /= (BPS - 1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %r14
cmpb $0x0, 0x4210(%rip)      # 0x8258
jne 0x404f
callq 0x3a95
leaq 0x131f(%rip), %rdi      # 0x5375
leaq 0x1329(%rip), %rdx      # 0x5386
movl $0x80, %ecx
movl $0x10, %r8d
movl $0xbd, %esi
callq 0x436b
movq %rax, %rbx
movl $0x8, %eax
movq -0x8(%r14,%rax), %rcx
movq %rcx, -0x8(%rbx,%rax)
movq (%r14,%rax), %rcx
movq %rcx, (%rbx,%rax)
addq $0x10, %rax
cmpq $0x808, %rax            # imm = 0x808
jne 0x407a
leaq 0xdb(%rip), %rcx        # 0x417a
movl $0x80, %esi
movl $0x10, %edx
movq %rbx, %rdi
callq 0x20b0
leaq 0x10(%rsp), %rdi
xorl %r14d, %r14d
movl $0x3f8, %edx            # imm = 0x3F8
xorl %esi, %esi
callq 0x2180
movq 0x11f3(%rip), %xmm0     # 0x52c0
movapd 0x11fb(%rip), %xmm1     # 0x52d0
movsd 0x1213(%rip), %xmm2     # 0x52f0
movq 0x18(%rbx,%r14,2), %rax
subq 0x8(%rbx,%r14,2), %rax
movq 0x10(%rbx,%r14,2), %rcx
movq %rax, %xmm3
punpckldq %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
subpd %xmm1, %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
addsd %xmm3, %xmm4
mulsd %xmm2, %xmm4
subq (%rbx,%r14,2), %rcx
movq %rcx, %xmm3
punpckldq %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
subpd %xmm1, %xmm3
movapd %xmm3, %xmm5
unpckhpd %xmm3, %xmm5            # xmm5 = xmm5[1],xmm3[1]
addsd %xmm3, %xmm5
divsd %xmm5, %xmm4
movsd %xmm4, 0x10(%rsp,%r14)
addq $0x8, %r14
cmpq $0x3f8, %r14            # imm = 0x3F8
jne 0x40dd
pxor %xmm0, %xmm0
xorl %eax, %eax
addsd 0x10(%rsp,%rax,8), %xmm0
incq %rax
cmpq $0x7f, %rax
jne 0x4144
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x2050
movsd 0x8(%rsp), %xmm0
divsd 0x1189(%rip), %xmm0     # 0x52f8
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/cli.c
// Function: cli_display_bars
static void cli_display_bars(cli_progress_s *t, cli_progress_s *c, cli_bps_s *bps)
{
	double total   = PERCENT * (t->offset + (1.0f * c->offset / c->size)) / t->size;
	double current = PERCENT * c->offset / c->size;
	bool single = t->size == 1;

	if (!single)
	{
		char name[CLI_TRUNCATED_DISPLAY_LONG] = { 0x0 };
		char *nm = c->display ? /*dir_get_name(c->display, '.')*/ : CLI_UNKNOWN;
		if (strlen(nm) < CLI_TRUNCATED_DISPLAY_LONG)
			strcpy(name, nm);
		else
		{
			strncpy(name, nm, CLI_TRUNCATED_DISPLAY_SHORT);
			strcat(name, CLI_TRUNCATED_ELLIPSE);
			if (cli_width > CLI_DEFAULT)
				strcat(name, nm + (strlen(nm) - CLI_TRUNCATED_DISPLAY_SHORT));
		}
		fprintf(stderr, "\x1B[1F"); // go up 1 line
		cli_display_bar(name, c, current);
		cli_display_bps(bps);
		fprintf(stderr, "\n");
	}
	cli_display_bar("Total", single ? c : t, total);

	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
testq %rcx, %rcx
js 0x41e7
cvtsi2ss %rcx, %xmm1
jmp 0x41fc
movq %rcx, %rdi
shrq %rdi
andl $0x1, %ecx
orq %rdi, %rcx
cvtsi2ss %rcx, %xmm1
addss %xmm1, %xmm1
movq 0x8(%rbx), %r14
testq %rax, %rax
js 0x420c
cvtsi2ss %rax, %xmm2
jmp 0x4221
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm2
addss %xmm2, %xmm2
movq (%rbx), %r15
cmpq $0x1, %r14
jne 0x422f
movq %rsi, %rbx
jmp 0x4266
movss 0x1129(%rip), %xmm0     # 0x5360
mulss %xmm1, %xmm0
divss %xmm2, %xmm0
cvtss2sd %xmm0, %xmm0
movq %rsi, %rdi
movq %rdx, %rsi
movss %xmm1, 0xc(%rsp)
movss %xmm2, 0x8(%rsp)
callq 0x27c1
movss 0x8(%rsp), %xmm2
movss 0xc(%rsp), %xmm1
divss %xmm2, %xmm1
testq %r15, %r15
js 0x4279
xorps %xmm0, %xmm0
cvtsi2ss %r15, %xmm0
jmp 0x4292
movq %r15, %rax
shrq %rax
andl $0x1, %r15d
orq %rax, %r15
xorps %xmm0, %xmm0
cvtsi2ss %r15, %xmm0
addss %xmm0, %xmm0
addss %xmm0, %xmm1
mulss 0x10c2(%rip), %xmm1     # 0x5360
testq %r14, %r14
js 0x42ad
xorps %xmm0, %xmm0
cvtsi2ss %r14, %xmm0
jmp 0x42c6
movq %r14, %rax
shrq %rax
andl $0x1, %r14d
orq %rax, %r14
xorps %xmm0, %xmm0
cvtsi2ss %r14, %xmm0
addss %xmm0, %xmm0
divss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x10d7(%rip), %rdi      # 0x53af
movq %rbx, %rsi
callq 0x268c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/cli.c
// Function: on_quit
extern void on_quit(int s)
{
	fprintf(stderr, "\e[?25h\n"); /* restore cursor */
	signal(s, SIG_DFL);
	raise(s);
	_exit(EXIT_FAILURE); // this shouldn't happen as the raise above will handle things
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movq 0x3d04(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0xf72(%rip), %rdi       # 0x5270
movl $0x7, %esi
movl $0x1, %edx
callq 0x2360
movl %ebx, %edi
xorl %esi, %esi
callq 0x2200
movl %ebx, %edi
callq 0x2040
movl $0x1, %edi
callq 0x2090
nop
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/mem.c
// Function: mem_mod
extern void *mem_mod(const char *file, int line, const char *func, size_t size)
{
	void *m = malloc(size);
	if (!m)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, size);
	return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rcx, %rdi
callq 0x2270
testq %rax, %rax
je 0x4352
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10eb(%rip), %rdi      # 0x5444
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3814
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/mem.c
// Function: mem_cod
extern void *mem_cod(const char *file, int line, const char *func, size_t count, size_t size)
{
	void *m = calloc(count, size);
	if (!m)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, size);
	return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rcx, %rdi
movq %r8, %rsi
callq 0x21e0
testq %rax, %rax
je 0x4398
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10a5(%rip), %rdi      # 0x5444
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3814
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/mem.c
// Function: mem_rod
extern void *mem_rod(const char *file, int line, const char *func, void *ptr, size_t newsize)
{
	void *m = realloc(ptr, newsize);
	if (!m)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, newsize);
	return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rcx, %rdi
movq %r8, %rsi
callq 0x22a0
testq %rax, %rax
je 0x43de
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x105f(%rip), %rdi      # 0x5444
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3814
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/mem.c
// Function: mem_sod
extern char *mem_sod(const char *file, int line, const char *func, const char *str)
{
	size_t len = strlen(str);
	char *new = strdup(str);
	if (!new)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, len);
	return new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rcx, %rdi
callq 0x2100
movq %rax, %r15
movq %r12, %rdi
callq 0x2380
testq %rax, %rax
je 0x442b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1012(%rip), %rdi      # 0x5444
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x3814
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/mem.c
// Function: mem_nod
extern char *mem_nod(const char *file, int line, const char *func, const char *str, size_t len)
{
	size_t olen = strlen(str);
	char *new = strndup(str, len);
	if (!new)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, olen < len ? len : olen);
	return new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rcx, %rdi
callq 0x2100
movq %rax, %r12
movq %r13, %rdi
movq %rbx, %rsi
callq 0x21c0
testq %rax, %rax
je 0x4487
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %rbx, %r12
cmovaq %r12, %rbx
leaq 0xfaf(%rip), %rdi       # 0x5444
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3814
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/mem.c
// Function: mem_aod
extern int mem_aod(const char *file, int line, const char *func, char **ptr, const char *template, ...)
{
	int r = 0;
	size_t l = strlen(template);
	va_list ap;
	va_start(ap, template);
#ifndef _WIN32
	r = vasprintf(ptr, template, ap);
#else
	if (!(*ptr))
		*ptr = mem_cod(file, line, func, l, VSN_SIZE);
	else
		*ptr = mem_rod(file, line, func, *ptr, l * VSN_SIZE);
	r = vsnprintf(*ptr, (l * VSN_SIZE) - 1, template, ap);
#endif
	va_end(ap);
	if (r < 0)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, l);
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, 0x8(%rsp)
movl %esi, %ebp
movq %rdi, %r14
leaq 0x30(%rsp), %rbx
movq %r9, 0x28(%rbx)
testb %al, %al
je 0x450f
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %r8, %rdi
callq 0x2100
movq %rax, %r15
leaq 0x10(%rsp), %rdx
movq %rbx, 0x10(%rdx)
leaq 0x120(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000028, %rax     # imm = 0x3000000028
movq %rax, (%rdx)
movq %r13, %rdi
movq %r12, %rsi
callq 0x20f0
testl %eax, %eax
js 0x455d
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xee0(%rip), %rdi       # 0x5444
movq %r14, %rsi
movl %ebp, %edx
movq 0x8(%rsp), %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x3814
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/common/src/mem.c
// Function: mem_fod
extern char *mem_fod(const char *file, int line, const char *func, const char *template, ...)
{
	int r = 0;
	size_t l = strlen(template);
	va_list ap;
	va_start(ap, template);

	char *ptr = NULL;
#ifndef _WIN32
	r = vasprintf(&ptr, template, ap);
#else
	ptr = mem_cod(file, line, func, l, VSN_SIZE);
	l *= VSN_SIZE;
	r = vsnprintf(ptr, l - 1, template, ap);
#endif
	va_end(ap);
	if (r < 0)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, l);
	return ptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x30(%rsp), %r13
movq %r8, 0x20(%r13)
movq %r9, 0x28(%r13)
testb %al, %al
je 0x45df
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %rcx, %rdi
callq 0x2100
movq %rax, %r15
leaq 0x10(%rsp), %rdx
movq %r13, 0x10(%rdx)
leaq 0x120(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000020, %rax     # imm = 0x3000000020
movq %rax, (%rdx)
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
movq %r12, %rsi
callq 0x20f0
testl %eax, %eax
js 0x463b
movq 0x8(%rsp), %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe02(%rip), %rdi       # 0x5444
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x3814
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/util.c
// Function: vwarn
static void
vwarn(const char *fmt, va_list ap)
{
	fprintf(stderr, "%s: ", argv0);
	vfprintf(stderr, fmt, ap);
	if (fmt[0] && fmt[strlen(fmt) - 1] == ':') {
		fputc(' ', stderr);
		perror(NULL);
	} else {
		fputc('\n', stderr);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x17d62(%rip), %r15     # 0x1aff8
movq (%r15), %rdi
movq 0x18e98(%rip), %rdx     # 0x1c138
leaq 0x12412(%rip), %rsi     # 0x156b9
xorl %eax, %eax
callq 0x3160
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3200
cmpb $0x0, (%rbx)
je 0x32d0
movq %rbx, %rdi
callq 0x3090
cmpb $0x3a, -0x1(%rbx,%rax)
je 0x32e0
movq (%r15), %rsi
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3110
movq (%r15), %rsi
pushq $0x20
popq %rdi
callq 0x3110
xorl %edi, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x31f0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/attr.c
// Function: attrspec
static bool
attrspec(struct attr *a, enum attrkind allowed)
{
	if (tok.kind != TLBRACK || !peek(TLBRACK))
		return false;
	while (parseattr(a, allowed, 0) || consume(TCOMMA))
		;
	expect(TRBRACK, "to end attribute specifier");
	expect(TRBRACK, "to end attribute specifier");
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x18cea(%rip), %rax     # 0x1c108
cmpl $0x40, (%rax)
jne 0x3479
movl %esi, %ebx
movq %rdi, %r14
movl $0x40, %edi
callq 0xafb3
testb %al, %al
je 0x3479
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x355b
testb %al, %al
jne 0x3436
movl $0x6e, %edi
callq 0xb099
testb %al, %al
jne 0x3436
leaq 0xeba9(%rip), %rbx      # 0x12004
movl $0x41, %edi
movq %rbx, %rsi
callq 0xb07a
movl $0x41, %edi
movq %rbx, %rsi
callq 0xb07a
movb $0x1, %al
jmp 0x347b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/attr.c
// Function: gnuattrspec
static bool
gnuattrspec(struct attr *a, enum attrkind allowed)
{
	if (!consume(T__ATTRIBUTE__))
		return false;
	while (parseattr(a, allowed, PREFIXGNU) || consume(TCOMMA))
		;
	expect(TLPAREN, "after '__attribute__' to begin attribute specifier");
	expect(TLPAREN, "after '__attribute__' to begin attribute specifier");
	while (parseattr(a, allowed, PREFIXGNU) || consume(TCOMMA))
		;
	expect(TRPAREN, "to end attribute specifier");
	expect(TRPAREN, "to end attribute specifier");
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movl $0x3f, %edi
callq 0xb099
movl %eax, %ebx
testb %al, %al
je 0x354e
movq %r14, %rdi
movl %ebp, %esi
movl $0x2, %edx
callq 0x355b
testb %al, %al
jne 0x34ca
movl $0x6e, %edi
callq 0xb099
testb %al, %al
jne 0x34ca
leaq 0xebc1(%rip), %r15      # 0x120b3
movl $0x42, %edi
movq %r15, %rsi
callq 0xb07a
movl $0x42, %edi
movq %r15, %rsi
callq 0xb07a
movq %r14, %rdi
movl %ebp, %esi
movl $0x2, %edx
callq 0x355b
testb %al, %al
jne 0x350c
movl $0x6e, %edi
callq 0xb099
testb %al, %al
jne 0x350c
leaq 0xead0(%rip), %r14      # 0x12004
movl $0x43, %edi
movq %r14, %rsi
callq 0xb07a
movl $0x43, %edi
movq %r14, %rsi
callq 0xb07a
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/attr.c
// Function: strip
static char *
strip(char *name)
{
	size_t len;

	len = strlen(name);
	if (len >= 4 && name[0] == '_' && name[1] == '_' && name[len - 2] == '_' && name[len - 1] == '_') {
		name[len - 2] = '\0';
		name += 2;
	}
	return name;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3090
cmpq $0x4, %rax
jb 0x3801
cmpb $0x5f, (%rbx)
jne 0x3801
cmpb $0x5f, 0x1(%rbx)
jne 0x3801
cmpb $0x5f, -0x2(%rbx,%rax)
jne 0x3801
cmpb $0x5f, -0x1(%rbx,%rax)
jne 0x3801
movb $0x0, -0x2(%rbx,%rax)
addq $0x2, %rbx
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/decl.c
// Function: mkdecl
struct decl *
mkdecl(char *name, enum declkind k, struct type *t, enum typequal tq, enum linkage linkage)
{
	struct decl *d;

	d = xmalloc(sizeof(*d));
	memset(d, 0, sizeof(*d));
	d->name = name;
	d->kind = k;
	d->linkage = linkage;
	d->type = t;
	d->qual = tq;
	if (k == DECLOBJECT && t)
		d->u.obj.align = t->align;

	return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r12
movl $0x48, %edi
callq 0xe13e
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movq $0x0, 0x40(%rax)
movq %r12, (%rax)
movl %r15d, 0x8(%rax)
movl %ebp, 0xc(%rax)
movq %rbx, 0x10(%rax)
movl %r14d, 0x18(%rax)
cmpl $0x1, %r15d
setne %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
jne 0x386c
movl 0x8(%rbx), %ecx
movl %ecx, 0x40(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/decl.c
// Function: typename
struct type *
typename(struct scope *s, enum typequal *tq, struct expr **toeval)
{
	struct qualtype t;

	t = declspecs(s, NULL, NULL, NULL);
	if (t.type) {
		t = declarator(s, t, NULL, NULL, true);
		if (tq)
			*tq |= t.qual;
		if (toeval)
			*toeval = t.expr;
	}
	return t.type;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3912
cmpq $0x0, (%r12)
je 0x3901
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x4ab2
movq 0x10(%r12), %rax
movq %rax, 0x30(%rsp)
movups (%r12), %xmm0
movaps %xmm0, 0x20(%rsp)
testq %r14, %r14
je 0x38f4
movl 0x28(%rsp), %eax
orl %eax, (%r14)
testq %rbx, %rbx
je 0x3901
movq 0x30(%rsp), %rax
movq %rax, (%rbx)
movq 0x20(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq