LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/ptd/ptd.c
// Function: subtilis_ptd_signx8to32
void subtilis_ptd_signx8to32(subtilis_ir_section_t *s, size_t start,
			     void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t src;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *signx = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(signx->operands[0].reg);
	src = subtilis_arm_ir_to_arm_reg(signx->operands[1].reg);

	subtilis_arm_add_signx(arm_s, SUBTILIS_ARM_INSTR_SXTB,
			       SUBTILIS_ARM_CCODE_AL, dest, src,
			       SUBTILIS_ARM_SIGNX_ROR_NONE, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6eea0
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6eea0
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x20(%rbp), %rax
movl $0xa9, %esi
movl $0xe, %edx
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x71eb0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/ptd/ptd.c
// Function: subtilis_ptd_sys_trans
size_t subtilis_ptd_sys_trans(const char *call_name)
{
	size_t *found;
	size_t error_bit = 0;

	if (call_name[0] == 'X') {
		call_name++;
		error_bit = 0x20000;
	}

	found = bsearch(call_name, &subtilis_ptd_swi_index[0],
			subtilis_ptd_known_swis, sizeof(*found),
			prv_sys_string_lookup);

	if (!found)
		return SIZE_MAX;

	return subtilis_ptd_swi_list[*found].num | error_bit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x58, %eax
jne 0xa3674
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq $0x20000, -0x20(%rbp)   # imm = 0x20000
movq -0x10(%rbp), %rdi
leaq 0xb291(%rip), %rax      # 0xae910
movq (%rax), %rdx
leaq 0xb297(%rip), %rsi      # 0xae920
movl $0x8, %ecx
leaq 0x4b(%rip), %r8         # 0xa36e0
callq 0x11270
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa36af
movq $-0x1, -0x8(%rbp)
jmp 0xa36cb
movq -0x18(%rbp), %rcx
leaq 0x2d3f6(%rip), %rax     # 0xd0ab0
imulq $0x18, (%rcx), %rcx
addq %rcx, %rax
movl (%rax), %eax
orq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/ptd/ptd.c
// Function: subtilis_ptd_asm_parse
void *subtilis_ptd_asm_parse(subtilis_lexer_t *l, subtilis_token_t *t,
			     void *backend_data, subtilis_type_section_t *stype,
			     const subtilis_settings_t *set,
			     subtilis_error_t *err)
{
	subtilis_arm_op_pool_t *pool = backend_data;

	return subtilis_arm_asm_parse(l, t, pool, stype, set,
				      subtilis_ptd_sys_trans,
				      SUBTILIS_PTD_PROGRAM_START, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %rax
leaq -0x187(%rip), %r9       # 0xa3640
movl $0xf000, (%rsp)         # imm = 0xF000
movq %rax, 0x8(%rsp)
callq 0x90040
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/backends/ptd/ptd.c
// Function: prv_cursor_on_off
static void prv_cursor_on_off(subtilis_ir_section_t *s, void *user_data,
			      uint32_t swtch, subtilis_error_t *err)
{
	size_t i;
	subtilis_arm_section_t *arm_s = user_data;
	uint32_t ar[] = {23, 1, 0, 0, 0, 0, 0, 0, 0, 0};

	ar[2] = swtch;

	for (i = 0; i < sizeof(ar) / sizeof(ar[0]); i++) {
		/* read_mask = 0 */
		/* write_mask = 0 */
		subtilis_arm_add_swi(arm_s, SUBTILIS_ARM_CCODE_AL,
				     256 + ar[i] + 0x20000, 0, 0, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	subtilis_riscos_handle_graphics_error(arm_s, s, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x11110
movl $0x17, -0x60(%rbp)
movl $0x1, -0x5c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x58(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0xa, -0x28(%rbp)
jae 0xa387b
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movl -0x60(%rbp,%rax,4), %eax
addl $0x100, %eax            # imm = 0x100
addl $0x20000, %eax          # imm = 0x20000
movl %eax, %eax
movl %eax, %edx
movq -0x20(%rbp), %r9
movl $0xe, %esi
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x70f30
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa386b
jmp 0xa388c
jmp 0xa386d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xa382b
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xa42d0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/examples/active.c
// Function: handle_reply
int handle_reply(xmpp_conn_t * const conn,
		 xmpp_stanza_t * const stanza,
		 void * const userdata)
{
    xmpp_stanza_t *query, *item;
    char *type;

    type = xmpp_stanza_get_type(stanza);
    if (strcmp(type, "error") == 0)
	fprintf(stderr, "ERROR: query failed\n");
    else {
	query = xmpp_stanza_get_child_by_name(stanza, "query");
	printf("Active Sessions:\n");
	for (item = xmpp_stanza_get_children(query); item; 
	     item = xmpp_stanza_get_next(item))
	    printf("\t %s\n", xmpp_stanza_get_attribute(item, "jid"));
	printf("END OF LIST\n");
    }

    /* disconnect */
    xmpp_disconnect(conn);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x120b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x11622(%rip), %rsi     # 0x13a9e
callq 0x2270
cmpl $0x0, %eax
jne 0x24a0
movq 0x15b5b(%rip), %rax     # 0x17fe8
movq (%rax), %rdi
leaq 0x10b6d(%rip), %rsi     # 0x13004
movb $0x0, %al
callq 0x20d0
jmp 0x2514
movq -0x10(%rbp), %rdi
leaq 0x10b6e(%rip), %rsi     # 0x13019
callq 0x12110
movq %rax, -0x20(%rbp)
leaq 0x10b64(%rip), %rdi     # 0x1301f
movb $0x0, %al
callq 0x2030
movq -0x20(%rbp), %rdi
callq 0x121f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2506
movq -0x28(%rbp), %rdi
leaq 0x10b56(%rip), %rsi     # 0x13037
callq 0x12420
movq %rax, %rsi
leaq 0x10b41(%rip), %rdi     # 0x13031
movb $0x0, %al
callq 0x2030
movq -0x28(%rbp), %rdi
callq 0x12210
movq %rax, -0x28(%rbp)
jmp 0x24cf
leaq 0x10b2e(%rip), %rdi     # 0x1303b
movb $0x0, %al
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x54e0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/examples/active.c
// Function: conn_handler
void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status, 
		  const int error, xmpp_stream_error_t * const stream_error,
		  void * const userdata)
{
    xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
    xmpp_stanza_t *iq, *query;

    if (status == XMPP_CONN_CONNECT) {
	fprintf(stderr, "DEBUG: connected\n");
	
	/* create iq stanza for request */
	iq = xmpp_stanza_new(ctx);
	xmpp_stanza_set_name(iq, "iq");
	xmpp_stanza_set_type(iq, "get");
	xmpp_stanza_set_id(iq, "active1");
	xmpp_stanza_set_attribute(iq, "to", "xxxxxxxxx.com");

	query = xmpp_stanza_new(ctx);
	xmpp_stanza_set_name(query, "query");
	xmpp_stanza_set_ns(query, XMPP_NS_DISCO_ITEMS);
	xmpp_stanza_set_attribute(query, "node", "sessions");

	xmpp_stanza_add_child(iq, query);

	/* we can release the stanza since it belongs to iq now */
	xmpp_stanza_release(query);

	/* set up reply handler */
	xmpp_id_handler_add(conn, handle_reply, "active1", ctx);

	/* send out the stanza */
	xmpp_send(conn, iq);

	/* release the stanza */
	xmpp_stanza_release(iq);
    } else {
	fprintf(stderr, "DEBUG: disconnected\n");
	xmpp_stop(ctx);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x2655
movq 0x15a85(%rip), %rax     # 0x17fe8
movq (%rax), %rdi
leaq 0x10adb(%rip), %rsi     # 0x13048
movb $0x0, %al
callq 0x20d0
movq -0x28(%rbp), %rdi
callq 0x11280
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x10ace(%rip), %rsi     # 0x1305a
callq 0x11b20
movq -0x30(%rbp), %rdi
leaq 0x10ac1(%rip), %rsi     # 0x1305d
callq 0x123f0
movq -0x30(%rbp), %rdi
leaq 0x10ab5(%rip), %rsi     # 0x13061
callq 0x123c0
movq -0x30(%rbp), %rdi
leaq 0x10aad(%rip), %rsi     # 0x13069
leaq 0x10aa9(%rip), %rdx     # 0x1306c
callq 0x11d30
movq -0x28(%rbp), %rdi
callq 0x11280
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x10a39(%rip), %rsi     # 0x13019
callq 0x11b20
movq -0x38(%rbp), %rdi
leaq 0x10a8a(%rip), %rsi     # 0x1307a
callq 0x11df0
movq -0x38(%rbp), %rdi
leaq 0x10aa1(%rip), %rsi     # 0x130a1
leaq 0x10a9f(%rip), %rdx     # 0x130a6
callq 0x11d30
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11e20
movq -0x38(%rbp), %rdi
callq 0x11550
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rcx
leaq -0x1e1(%rip), %rsi      # 0x2450
leaq 0x10a29(%rip), %rdx     # 0x13061
callq 0x76d0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5860
movq -0x30(%rbp), %rdi
callq 0x11550
jmp 0x2676
movq 0x1598c(%rip), %rax     # 0x17fe8
movq (%rax), %rdi
leaq 0x10a49(%rip), %rsi     # 0x130af
movb $0x0, %al
callq 0x20d0
movq -0x28(%rbp), %rdi
callq 0x6c40
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/examples/active.c
// Function: main
int main(int argc, char **argv)
{
    xmpp_ctx_t *ctx;
    xmpp_conn_t *conn;

    if (argc != 3) {
	fprintf(stderr, "Usage: active <jid> <pass>\n\n");
	return 1;
    }

    /* initialize lib */
    xmpp_initialize();

    /* create a context */
    ctx = xmpp_ctx_new(NULL, NULL);

    /* create a connection */
    conn = xmpp_conn_new(ctx);

    /* setup authentication information */
    xmpp_conn_set_jid(conn, argv[1]);
    xmpp_conn_set_pass(conn, argv[2]);

    /* initiate connection */
    xmpp_connect_client(conn, NULL, 0, conn_handler, ctx);

    /* start the event loop */
    xmpp_run(ctx);

    /* release our connection and context */
    xmpp_conn_release(conn);
    xmpp_ctx_free(ctx);

    /* shutdown lib */
    xmpp_shutdown();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x26c0
movq 0x15945(%rip), %rax     # 0x17fe8
movq (%rax), %rdi
leaq 0x10a17(%rip), %rsi     # 0x130c4
movb $0x0, %al
callq 0x20d0
movl $0x1, -0x4(%rbp)
jmp 0x2745
callq 0x5b60
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x60f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4630
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5010
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x5090
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %r8
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
leaq -0x1e9(%rip), %rcx      # 0x2530
callq 0x5110
movq -0x18(%rbp), %rdi
callq 0x6be0
movq -0x20(%rbp), %rdi
callq 0x4c20
movq -0x18(%rbp), %rdi
callq 0x61b0
callq 0x5b70
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/identify/identify.c
// Function: correlate
static int
correlate(int *data,int length,int window, double *result)
    {
    int i,j;
    double sum;
    double totalSum;

    totalSum = 0;
    result[0] = 1.0;
    for (i = 1; i < length - window; ++i)
        {
        sum = 0;
        for (j = 0; j < window; ++j)
            sum += pow(data[j] - data[i + j],2);
        totalSum += sum;

        result[i] = sum / (totalSum / i);
        }

    return length - window;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movsd 0x3516(%rip), %xmm0     # 0x6010
movsd %xmm0, (%rax)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0xc(%rbp), %ecx
subl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jge 0x2baf
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2b6e
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl -0x20(%rbp), %edx
movslq %edx, %rdx
subl (%rcx,%rdx,4), %eax
cvtsi2sd %eax, %xmm0
movsd 0x34cc(%rip), %xmm1     # 0x6020
callq 0x2060
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2b25
movsd -0x28(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
cvtsi2sdl -0x1c(%rbp), %xmm2
divsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2b05
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/identify/identify.c
// Function: findMinError
static int
findMinError(double *errors,int length,double *worst)
    {
    int i;
    int min;

    /* find the first peak of the error function */

    //printf("findMinError: looking from %d to %d\n",skip,length);

    *worst = 0;

    for (i = skip; i < length; ++i)
        {
        if (errors[i] > *worst) *worst = errors[i];
        if (errors[i] < errors[i-1]) break;
        }

    /* starting the downhill side of the first peak */
    /* now find the minumum */

    //printf("searching from min starting from %d\n",i);
    min = i;
    for ( ; i < length; ++i)
        {
        if (errors[i] > *worst) *worst = errors[i];
        if (errors[i] < errors[min]) min = i;
        }

    //printf("wavelength is %d\n",min);

    return min;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl 0x6d10(%rip), %eax      # 0x98f0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2c4b
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0x2c17
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2c3e
jmp 0x2c4b
jmp 0x2c40
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2be3
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2cb8
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0x2c85
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2cab
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x2cad
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2c51
movl -0x20(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/identify/identify.c
// Function: findMinErrorAt
static int
findMinErrorAt(double *errors,int spot)
    {
    int i;
    int min;

    min = spot;
    //printf("search from %f seconds to %f seconds\n",
    //    (spot - skip/2.) / 44100,
    //    (spot + skip/2.) / 44100);
    for (i = spot - skip/2; i < spot + skip/2; ++i)
    for (i = spot - skip/2; i < spot + skip/2; ++i)
        {
        if (errors[i] < errors[min]) min = i;
        }

    if (min == spot-2 || min == spot || min == spot+2)
        return min;
    else
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl 0x6c13(%rip), %eax      # 0x98f0
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x20(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %ecx
movl 0x6bf2(%rip), %eax      # 0x98f0
movl $0x2, %esi
cltd
idivl %esi
movl %eax, %edx
movl -0x24(%rbp), %eax
addl %edx, %ecx
cmpl %ecx, %eax
jge 0x2d98
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movl 0x6bcf(%rip), %eax      # 0x98f0
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %ecx
movl 0x6bae(%rip), %eax      # 0x98f0
movl $0x2, %esi
cltd
idivl %esi
movl %eax, %edx
movl -0x2c(%rbp), %eax
addl %edx, %ecx
cmpl %ecx, %eax
jge 0x2d88
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2d7b
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2d7d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2d33
jmp 0x2d8a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2cef
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
je 0x2dba
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x2dba
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jne 0x2dc2
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2dc9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Keith-S-Thompson[P]kst-time-utils/gettimeofday.c
// Function: main
int main(void) {
    struct timeval tv = { 0, 0 };

    if (gettimeofday(&tv, NULL) == 0) {
        printf("%ld.%06ld\n", (long)tv.tv_sec, (long)tv.tv_usec);
        exit(EXIT_SUCCESS);
    }
    else {
        perror("gettimeofday");
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1050
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1040
cmpl $0x0, %eax
jne 0x11ce
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xe44(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
xorl %edi, %edi
callq 0x1070
leaq 0xe3a(%rip), %rdi       # 0x200f
callq 0x1060
movl $0x1, %edi
callq 0x1070
// File: /workspace/github_c_makefile_star2_O0/cirocosta[P]stress/src/mem-rw.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { 0 };

	setbuf(stdout, NULL);
	stress_parse_args(argc, argv, &args);
	allocate_and_use(args.n);

	return 0;
}

// Assembly:
subq $0x2018, %rsp           # imm = 0x2018
movl $0x0, 0x2014(%rsp)
movl %edi, 0x2010(%rsp)
movq %rsi, 0x2008(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x2008, %edx           # imm = 0x2008
callq 0x10b0
movq 0x2311(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
movl 0x2010(%rsp), %edi
movq 0x2008(%rsp), %rsi
movq %rsp, %rdx
callq 0x12e0
movl (%rsp), %edi
callq 0x18a0
xorl %eax, %eax
addq $0x2018, %rsp           # imm = 0x2018
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/benchmark.c
// Function: resize
clock_t resize(struct bench_image image, int out_width, int out_height)
{
	int i;
	enum oil_colorspace cs;
	struct oil_scale os;
	unsigned char *inbuf, *outbuf;
	size_t in_row_stride;
	clock_t t;

	cs = image.cs;
	in_row_stride = image.width * OIL_CMP(cs);

	inbuf = image.buffer;
	outbuf = malloc(out_width * OIL_CMP(cs));

	t = clock();
	oil_scale_init(&os, image.height, out_height, image.width, out_width, cs);
	for(i=0; i<out_height; i++) {
		while (oil_scale_slots(&os)) {
			oil_scale_in(&os, inbuf);
			inbuf += in_row_stride;
		}
		oil_scale_out(&os, outbuf);
	}
	t = clock() - t;
	free(outbuf);
	oil_scale_free(&os);
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0x10(%rax), %ecx
movl %ecx, -0x10(%rbp)
movl 0x8(%rax), %ecx
movl -0x10(%rbp), %edx
andl $0xff, %edx
imull %edx, %ecx
movl %ecx, %ecx
movq %rcx, -0x80(%rbp)
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movl -0x4(%rbp), %eax
movl -0x10(%rbp), %ecx
andl $0xff, %ecx
imull %ecx, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x1150
movq %rax, -0x78(%rbp)
callq 0x10a0
movq %rax, %rcx
movq -0x90(%rbp), %rax
movq %rcx, -0x88(%rbp)
movl 0xc(%rax), %esi
movl -0x8(%rbp), %edx
movl 0x8(%rax), %ecx
movl -0x4(%rbp), %r8d
movl -0x10(%rbp), %r9d
leaq -0x68(%rbp), %rdi
callq 0x1580
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x429c
jmp 0x425b
leaq -0x68(%rbp), %rdi
callq 0x1a90
cmpl $0x0, %eax
je 0x4284
movq -0x70(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1b20
movq -0x80(%rbp), %rax
addq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x425b
movq -0x78(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1f50
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4251
callq 0x10a0
subq -0x88(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rdi
callq 0x1040
leaq -0x68(%rbp), %rdi
callq 0x1940
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/benchmark.c
// Function: do_bench
void do_bench(struct bench_image image, double ratio, int iterations)
{
	int i, out_width, out_height;
	clock_t t_min, t_tmp;

	out_width = round(image.width * ratio);
	out_height = 500000; /* reasonable maximum height */

	oil_fix_ratio(image.width, image.height, &out_width, &out_height);

	t_min = 0;
	for (i=0; i<iterations; i++) {
		t_tmp = resize(image, out_width, out_height);
		if (!t_min || t_tmp < t_min) {
			t_min = t_tmp;
		}
	}

	printf("    to %4dx%4d %6.2fms\n", out_width, out_height, time_to_ms(t_min));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
cvtsi2sdl 0x8(%rax), %xmm0
mulsd -0x8(%rbp), %xmm0
callq 0x1060
movq -0x30(%rbp), %rax
cvttsd2si %xmm0, %ecx
movl %ecx, -0x14(%rbp)
movl $0x7a120, -0x18(%rbp)   # imm = 0x7A120
movl 0x8(%rax), %edi
movl 0xc(%rax), %esi
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x2200
movq $0x0, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4395
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x41c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4380
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x4388
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x438a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x433b
movl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
callq 0x41a0
movl -0x38(%rbp), %esi
movl -0x34(%rbp), %edx
leaq 0xd21(%rip), %rdi       # 0x50d8
movb $0x1, %al
callq 0x10d0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/benchmark.c
// Function: do_bench_sizes
void do_bench_sizes(char *name, char *path, enum oil_colorspace cs, int iterations)
{
	struct bench_image image;

	image = png(path, cs);

	printf("%dx%d %s\n", image.width, image.height, name);

	do_bench(image, 0.01, iterations);
	do_bench(image, 0.125, iterations);
	do_bench(image, 0.8, iterations);
	do_bench(image, 2.14, iterations);

	free(image.buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rdi
callq 0x44f0
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %esi
movl -0x24(%rbp), %edx
movq -0x8(%rbp), %rcx
leaq 0xcd1(%rip), %rdi       # 0x50f0
movb $0x0, %al
callq 0x10d0
movl -0x18(%rbp), %edi
leaq -0x30(%rbp), %rax
movsd 0xc9b(%rip), %xmm0      # 0x50d0
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x42e0
movl -0x18(%rbp), %edi
leaq -0x30(%rbp), %rax
movsd 0xc66(%rip), %xmm0      # 0x50c8
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x42e0
movl -0x18(%rbp), %edi
leaq -0x30(%rbp), %rax
movsd 0xc31(%rip), %xmm0      # 0x50c0
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x42e0
movl -0x18(%rbp), %edi
leaq -0x30(%rbp), %rax
movsd 0xbfc(%rip), %xmm0      # 0x50b8
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x42e0
movq -0x30(%rbp), %rdi
callq 0x1040
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/joltikeq9696v13/ref/joltik.c
// Function: set_block_number_in_tweak
static void set_block_number_in_tweak(uint8_t *tweak, const uint64_t block_no) {
    tweak[ 4] = ((block_no >> 56ULL) & 0x0f);
    tweak[ 5] = ((block_no >> 48ULL) & 0xff);
    tweak[ 6] = ((block_no >> 40ULL) & 0xff);
    tweak[ 7] = ((block_no >> 32ULL) & 0xff);
    tweak[ 8] = ((block_no >> 24ULL) & 0xff);
    tweak[ 9] = ((block_no >> 16ULL) & 0xff);
    tweak[10] = ((block_no >>  8ULL) & 0xff);
    tweak[11] = ((block_no >>  0ULL) & 0xff);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
shrq $0x38, %rax
andq $0xf, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rsp), %rax
shrq $0x30, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x5(%rax)
movq -0x10(%rsp), %rax
shrq $0x28, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rsp), %rax
shrq $0x20, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x7(%rax)
movq -0x10(%rsp), %rax
shrq $0x18, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x8(%rax)
movq -0x10(%rsp), %rax
shrq $0x10, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x9(%rax)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0xa(%rax)
movq -0x10(%rsp), %rax
shrq $0x0, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0xb(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vlenhart[P]q3bsp/./stb_image_write.h
// Function: outfile(char const*, int, int, int, int, int, int, void*, int, int, char const*, ...)
static int outfile(char const *filename, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...)
{
   FILE *f;
   if (y < 0 || x < 0) return 0;
   f = fopen(filename, "wb");
   if (f) {
      va_list v;
      va_start(v, fmt);
      writefv(f, fmt, v);
      va_end(v);
      write_pixels(f,rgb_dir,vdir,x,y,comp,data,alpha,pad,expand_mono);
      fclose(f);
   }
   return f != NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
testb %al, %al
je 0x44bf
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq 0x30(%rbp), %rax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x44f1
cmpl $0x0, -0x24(%rbp)
jge 0x44fd
movl $0x0, -0xc(%rbp)
jmp 0x45a5
movq -0x18(%rbp), %rdi
leaq 0x24d2b(%rip), %rsi     # 0x29233
callq 0x3370
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x4595
leaq -0x50(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x30, (%rax)
movq -0x38(%rbp), %rdi
movq 0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x8b90
leaq -0x50(%rbp), %rax
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x2c(%rbp), %r9d
movq 0x18(%rbp), %rbx
movl 0x20(%rbp), %r11d
movl 0x28(%rbp), %r10d
movl 0x10(%rbp), %eax
movq %rbx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0x8d80
movq -0x38(%rbp), %rdi
callq 0x3290
cmpq $0x0, -0x38(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbi_write_tga
int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
{
   int has_alpha = (comp == 2 || comp == 4);
   int colorbytes = has_alpha ? comp-1 : comp;
   int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3
   return outfile(filename, -1,-1, x, y, comp, 0, (void *) data, has_alpha, 0,
                  "111 221 2222 11", 0,0,format, 0,0,0, 0,0,x,y, (colorbytes+has_alpha)*8, has_alpha*8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movl %edx, -0x38(%rbp)
movl %ecx, -0x3c(%rbp)
movq %r8, -0x48(%rbp)
movb $0x1, %al
cmpl $0x2, -0x3c(%rbp)
movb %al, -0x55(%rbp)
je 0x45fa
cmpl $0x4, -0x3c(%rbp)
sete %al
movb %al, -0x55(%rbp)
movb -0x55(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x4616
movl -0x3c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x461c
movl -0x3c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %edx
movl $0x2, %eax
movl $0x3, %ecx
cmpl $0x2, %edx
cmovll %ecx, %eax
movl %eax, -0x54(%rbp)
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %ecx
movl -0x38(%rbp), %r8d
movl -0x3c(%rbp), %r9d
movq -0x48(%rbp), %r13
movl -0x4c(%rbp), %r12d
movl -0x54(%rbp), %r14d
movl -0x34(%rbp), %ebx
movl -0x38(%rbp), %r11d
movl -0x50(%rbp), %r10d
addl -0x4c(%rbp), %r10d
shll $0x3, %r10d
movl -0x4c(%rbp), %eax
shll $0x3, %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %esi, %esi
leaq 0x24b04(%rip), %r15     # 0x2917e
movl %edx, %esi
movl $0x0, (%rsp)
movq %r13, 0x8(%rsp)
movl %r12d, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movl $0x0, 0x30(%rsp)
movl %r14d, 0x38(%rsp)
movl $0x0, 0x40(%rsp)
movl $0x0, 0x48(%rsp)
movl $0x0, 0x50(%rsp)
movl $0x0, 0x58(%rsp)
movl $0x0, 0x60(%rsp)
movl %ebx, 0x68(%rsp)
movl %r11d, 0x70(%rsp)
movl %r10d, 0x78(%rsp)
movl %eax, 0x80(%rsp)
movb $0x0, %al
callq 0x4480
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__write_run_data(_IO_FILE*, int, unsigned char)
void stbiw__write_run_data(FILE *f, int length, unsigned char databyte)
{
   unsigned char lengthbyte = (unsigned char) (length+128);
   STBIW_ASSERT(length+128 <= 255);
   fwrite(&lengthbyte, 1, 1, f);
   fwrite(&databyte, 1, 1, f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
addl $0x80, %eax
movb %al, -0xe(%rbp)
movl -0xc(%rbp), %eax
addl $0x80, %eax
cmpl $0xff, %eax
jg 0x48d0
jmp 0x48ef
leaq 0x248b7(%rip), %rdi     # 0x2918e
leaq 0x248c2(%rip), %rsi     # 0x291a0
movl $0x109, %edx            # imm = 0x109
leaq 0x248ca(%rip), %rcx     # 0x291b4
callq 0x31c0
movq -0x8(%rbp), %rcx
leaq -0xe(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x3560
movq -0x8(%rbp), %rcx
leaq -0xd(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x3560
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__write_dump_data(_IO_FILE*, int, unsigned char*)
void stbiw__write_dump_data(FILE *f, int length, unsigned char *data)
{
   unsigned char lengthbyte = (unsigned char )(length & 0xff);
   STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code
   fwrite(&lengthbyte, 1, 1, f);
   fwrite(data, length, 1, f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, -0x19(%rbp)
cmpl $0x80, -0xc(%rbp)
jg 0x4949
jmp 0x4968
leaq 0x2489b(%rip), %rdi     # 0x291eb
leaq 0x24849(%rip), %rsi     # 0x291a0
movl $0x111, %edx            # imm = 0x111
leaq 0x24896(%rip), %rcx     # 0x291f9
callq 0x31c0
movq -0x8(%rbp), %rcx
leaq -0x19(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x3560
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
movq -0x8(%rbp), %rcx
movl $0x1, %edx
callq 0x3560
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbi_write_hdr
int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)
{
   int i;
   FILE *f;
   if (y <= 0 || x <= 0 || data == NULL) return 0;
   f = fopen(filename, "wb");
   if (f) {
      /* Each component is stored separately. Allocate scratch space for full output scanline. */
      unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4);
      fprintf(f, "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n"      );
      fprintf(f, "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n"                 , y, x);
      for(i=0; i < y; i++)
         stbiw__write_hdr_scanline(f, x, comp, scratch, data + comp*i*x);
      STBIW_FREE(scratch);
      fclose(f);
   }
   return f != NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x4ddc
cmpl $0x0, -0x14(%rbp)
jle 0x4ddc
cmpq $0x0, -0x28(%rbp)
jne 0x4de8
movl $0x0, -0x4(%rbp)
jmp 0x4eaa
movq -0x10(%rbp), %rdi
leaq 0x24440(%rip), %rsi     # 0x29233
callq 0x3370
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x4e9a
movl -0x14(%rbp), %eax
shll $0x2, %eax
movslq %eax, %rdi
callq 0x33e0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x24412(%rip), %rsi     # 0x29236
movb $0x0, %al
callq 0x3430
movq -0x38(%rbp), %rdi
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x2443c(%rip), %rsi     # 0x29278
movb $0x0, %al
callq 0x3430
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4e88
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x1c(%rbp), %edx
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %r8
movl -0x1c(%rbp), %eax
imull -0x2c(%rbp), %eax
imull -0x14(%rbp), %eax
cltq
shlq $0x2, %rax
addq %rax, %r8
callq 0x49a0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4e4a
movq -0x40(%rbp), %rdi
callq 0x3380
movq -0x38(%rbp), %rdi
callq 0x3290
cmpq $0x0, -0x38(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__sbgrowf(void**, int, int)
static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)
{
   int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1;
   void *p = STBIW_REALLOC(*arr ? stbiw__sbraw(*arr) : 0, itemsize * m + sizeof(int)*2);
   STBIW_ASSERT(p);
   if (p) {
      if (!*arr) ((int *) p)[1] = 0;
      *arr = (void *) ((int *) p + 2);
      stbiw__sbm(*arr) = m;
   }
   return *arr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5ba0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x8(%rax), %eax
shll %eax
addl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x5ba9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5bca
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $-0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x5bd2
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x5bd2
movq -0x30(%rbp), %rdi
movl -0x10(%rbp), %eax
imull -0x14(%rbp), %eax
movslq %eax, %rsi
addq $0x8, %rsi
callq 0x34d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5bf6
jmp 0x5c15
leaq 0x24ae7(%rip), %rdi     # 0x2a6e4
leaq 0x2359c(%rip), %rsi     # 0x291a0
movl $0x196, %edx            # imm = 0x196
leaq 0x23dfb(%rip), %rcx     # 0x29a0b
callq 0x31c0
cmpq $0x0, -0x20(%rbp)
je 0x5c4d
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5c31
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %ecx, -0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__zlib_flushf(unsigned char*, unsigned int*, int*)
static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
{
   while (*bitcount >= 8) {
      stbiw__sbpush(data, (unsigned char) *bitbuffer);
      *bitbuffer >>= 8;
      *bitcount -= 8;
   }
   return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jl 0x5ce4
cmpq $0x0, -0x8(%rbp)
je 0x5c97
movq -0x8(%rbp), %rax
movl -0x4(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cmpl -0x8(%rcx), %eax
jl 0x5ca9
leaq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x5b70
jmp 0x5cab
jmp 0x5cab
movq -0x10(%rbp), %rax
movl (%rax), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rsi
movl -0x4(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, -0x4(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
shrl $0x8, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
subl $0x8, %ecx
movl %ecx, (%rax)
jmp 0x5c74
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__crc32(unsigned char*, int)
unsigned int stbiw__crc32(unsigned char *buffer, int len)
{
   static unsigned int crc_table[256];
   unsigned int crc = ~0u;
   int i,j;
   if (crc_table[1] == 0)
      for(i=0; i < 256; i++)
         for (crc_table[i]=i, j=0; j < 8; ++j)
            crc_table[i] = (crc_table[i] >> 1) ^ (crc_table[i] & 1 ? 0xedb88320 : 0);
   for (i=0; i < len; ++i)
      crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
   return ~crc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, 0x375fb(%rip)     # 0x3d434
jne 0x5ec5
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x5ec3
movl -0x14(%rbp), %edx
movslq -0x14(%rbp), %rcx
leaq 0x375d3(%rip), %rax     # 0x3d430
movl %edx, (%rax,%rcx,4)
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0x5eb6
movslq -0x14(%rbp), %rcx
leaq 0x375b8(%rip), %rax     # 0x3d430
movl (%rax,%rcx,4), %edx
shrl %edx
movslq -0x14(%rbp), %rcx
leaq 0x375a8(%rip), %rax     # 0x3d430
movl (%rax,%rcx,4), %esi
andl $0x1, %esi
xorl %eax, %eax
movl $0xedb88320, %ecx       # imm = 0xEDB88320
cmpl $0x0, %esi
cmovnel %ecx, %eax
xorl %eax, %edx
movslq -0x14(%rbp), %rcx
leaq 0x37588(%rip), %rax     # 0x3d430
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5e67
jmp 0x5eb8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5e46
jmp 0x5ec5
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5f0d
movl -0x10(%rbp), %eax
shrl $0x8, %eax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movl -0x10(%rbp), %edx
andl $0xff, %edx
xorl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x37534(%rip), %rcx     # 0x3d430
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5ecc
movl -0x10(%rbp), %eax
xorl $-0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__paeth(int, int, int)
static unsigned char stbiw__paeth(int a, int b, int c)
{
   int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c);
   if (pa <= pb && pa <= pc) return (unsigned char) a;
   if (pb <= pc) return (unsigned char) b;
   return (unsigned char) c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x6951
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x6951
movl -0x8(%rbp), %eax
movb %al, -0x1(%rbp)
jmp 0x6967
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x6961
movl -0xc(%rbp), %eax
movb %al, -0x1(%rbp)
jmp 0x6967
movl -0x10(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbi_write_png
int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
{
   FILE *f;
   int len;
   unsigned char *png = stbi_write_png_to_mem((unsigned char *) data, stride_bytes, x, y, comp, &len);
   if (!png) return 0;
   f = fopen(filename, "wb");
   if (!f) { STBIW_FREE(png); return 0; }
   fwrite(png, 1, len, f);
   fclose(f);
   STBIW_FREE(png);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
leaq -0x3c(%rbp), %r9
callq 0x5f20
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x6a4b
movl $0x0, -0x4(%rbp)
jmp 0x6aa7
movq -0x10(%rbp), %rdi
leaq 0x227dd(%rip), %rsi     # 0x29233
callq 0x3370
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x6a78
movq -0x48(%rbp), %rdi
callq 0x3380
movl $0x0, -0x4(%rbp)
jmp 0x6aa7
movq -0x48(%rbp), %rdi
movslq -0x3c(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl $0x1, %esi
callq 0x3560
movq -0x38(%rbp), %rdi
callq 0x3290
movq -0x48(%rbp), %rdi
callq 0x3380
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vlenhart[P]q3bsp/./main.h
// Function: strlwr(char*)
char * strlwr(char * string) {
    int length = strlen(string);
    for (int i = 0; i < length; ++i)
    {
        string[i] = tolower(string[i]);
    }
    return string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3150
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6b00
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x3440
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6acf
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vlenhart[P]q3bsp/./main.h
// Function: strupr(char*)
char * strupr(char * string) {
    int length = strlen(string);
    for (int i = 0; i < length; ++i)
    {
        string[i] = toupper(string[i]);
    }
    return string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3150
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6b60
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x3540
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6b2f
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vlenhart[P]q3bsp/./vformat.h
// Function: VFormatOptions::VFormatOptions()
VFormatOptions() {
		appearanceCount=0;
		textureCount=0;
		matDefined = false;

		vrml2=true;
		verbose=false;
		useBsp=false;

		useEffects=true;

		usePng = true; // use PNG format for lightmap-images, else BMP
		useLighting = false; // emit VRML 2 unlit geometry 
		useMat = false;

		useMultiTexturing = false; // emit VRML Contact 3D MultiTexture proposed nodes

		maxStage=8;
		yzFlip = true; // true VRML Y <=> Z 

		//VFORMAT ="%f %f %f";
		VFORMAT = "%g %g %g";
		TFORMAT  = "%g %g";
		CFORMAT = "%.3f %.3f %.3f";

		useMat = true;

		if (useMat) blendMode = "mode [\"MODULATE\" \"ADD\" ]";
		else blendMode = "mode [\"REPLACE\" \"MODULATE\" ]";
		//blendMode = "mode [\"MODULATE\" \"MODULATE\" ]"; // too dark
		//blendMode = "mode [\"MODULATE\" \"ADDSIGNED\" ]";

		if (useMat) blendMode = "mode [\"DIFFUSE_ADD,SELECTARG2\" \"MODULATE\" ]";

		stage0Mode= "MODULATE";
		lightMapMode = "MODULATE";

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x9460
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x9460
movq -0x10(%rbp), %rax
movl $0x0, 0x60(%rax)
movl $0x0, 0x64(%rax)
movb $0x0, 0xb0(%rax)
movb $0x1, 0x68(%rax)
movb $0x0, 0x69(%rax)
movb $0x0, 0x6b(%rax)
movb $0x1, 0x77(%rax)
movb $0x1, 0x74(%rax)
movb $0x0, 0x75(%rax)
movb $0x0, 0x76(%rax)
movb $0x0, 0x6a(%rax)
movl $0x8, 0x70(%rax)
movb $0x1, 0x78(%rax)
leaq 0x20912(%rip), %rcx     # 0x29a33
movq %rcx, 0x80(%rax)
leaq 0x20907(%rip), %rcx     # 0x29a36
movq %rcx, 0x88(%rax)
leaq 0x208ff(%rip), %rcx     # 0x29a3c
movq %rcx, 0x90(%rax)
movb $0x1, 0x76(%rax)
testb $0x1, 0x76(%rax)
je 0x9162
movq -0x10(%rbp), %rax
leaq 0x208f2(%rip), %rcx     # 0x29a4b
movq %rcx, 0x98(%rax)
jmp 0x9174
movq -0x10(%rbp), %rax
leaq 0x208f7(%rip), %rcx     # 0x29a64
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x76(%rax)
je 0x9190
movq -0x10(%rbp), %rax
leaq 0x208f8(%rip), %rcx     # 0x29a81
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
leaq 0x20912(%rip), %rcx     # 0x29aad
movq %rcx, 0xa0(%rax)
leaq 0x20904(%rip), %rcx     # 0x29aad
movq %rcx, 0xa8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)