LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_north_west
void mouse_resize_north_west(void *arg) {
	if (!mouse_resize((press_arg *)arg)) {
		return;
	}
	
	grab_pointer_cursor(resize_cursors[0]);
	
	mouse_resize_set_x_west((press_arg *)arg);
	mouse_resize_set_y_north((press_arg *)arg);
	mouse_resize_set_east();
	mouse_resize_set_south();

	events[XCB_MOTION_NOTIFY] = (void (*)(xcb_generic_event_t *))mouse_resize_motion_north_west_start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x70f8
testl %eax, %eax
je 0x74e9
leaq 0x6482(%rip), %rax      # 0xd910
movl (%rax), %edi
callq 0x6ebb
movl 0x4(%rbx), %eax
leaq 0x65d1(%rip), %rcx      # 0xda70
movslq (%rcx), %rcx
imulq $0x50, %rcx, %rcx
leaq 0x6483(%rip), %rdx      # 0xd930
movq 0x48(%rdx,%rcx), %rcx
subl 0x108(%rcx), %eax
movl %eax, 0x65c6(%rip)      # 0xda84
movl 0x8(%rbx), %eax
subl 0x10c(%rcx), %eax
movl %eax, 0x65bb(%rip)      # 0xda88
callq 0x735e
callq 0x7283
leaq 0x12(%rip), %rax        # 0x74f0
leaq 0x5feb(%rip), %rcx      # 0xd4d0
movq %rax, 0x30(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_north_east
void mouse_resize_north_east(void *arg) {
	if (!mouse_resize((press_arg *)arg)) {
		return;
	}
	
	grab_pointer_cursor(resize_cursors[2]);
	
	mouse_resize_set_x_east((press_arg *)arg);
	mouse_resize_set_y_north((press_arg *)arg);
	mouse_resize_set_south();

	events[XCB_MOTION_NOTIFY] = (void (*)(xcb_generic_event_t *))mouse_resize_motion_north_east_start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x70f8
testl %eax, %eax
je 0x75a1
leaq 0x63c6(%rip), %rax      # 0xd910
movl 0x8(%rax), %edi
callq 0x6ebb
leaq 0x6517(%rip), %rax      # 0xda70
movslq (%rax), %rax
imulq $0x50, %rax, %rax
leaq 0x63c9(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rax
movl 0x110(%rax), %ecx
subl 0x4(%rbx), %ecx
movl %ecx, 0x6509(%rip)      # 0xda84
movl 0x8(%rbx), %ecx
subl 0x10c(%rax), %ecx
movl %ecx, 0x64fe(%rip)      # 0xda88
callq 0x7283
leaq 0x12(%rip), %rax        # 0x75a8
leaq 0x5f33(%rip), %rcx      # 0xd4d0
movq %rax, 0x30(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_south_west
void mouse_resize_south_west(void *arg) {
	if (!mouse_resize((press_arg *)arg)) {
		return;
	}
	
	grab_pointer_cursor(resize_cursors[6]);
	
	mouse_resize_set_x_west((press_arg *)arg);
	mouse_resize_set_y_south((press_arg *)arg);
	mouse_resize_set_east();

	events[XCB_MOTION_NOTIFY] = (void (*)(xcb_generic_event_t *))mouse_resize_motion_south_west_start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x70f8
testl %eax, %eax
je 0x7659
leaq 0x630e(%rip), %rax      # 0xd910
movl 0x18(%rax), %edi
callq 0x6ebb
movl 0x4(%rbx), %eax
leaq 0x645c(%rip), %rcx      # 0xda70
movslq (%rcx), %rcx
imulq $0x50, %rcx, %rcx
leaq 0x630e(%rip), %rdx      # 0xd930
movq 0x48(%rdx,%rcx), %rcx
subl 0x108(%rcx), %eax
movl %eax, 0x6451(%rip)      # 0xda84
movl 0x114(%rcx), %eax
subl 0x8(%rbx), %eax
movl %eax, 0x6446(%rip)      # 0xda88
callq 0x735e
leaq 0x12(%rip), %rax        # 0x7660
leaq 0x5e7b(%rip), %rcx      # 0xd4d0
movq %rax, 0x30(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_move_motion
static void mouse_move_motion(void *arg) {
	if (stack[curws].fwin->snap_index != SNAP_NONE) {
		return;
	}

	xcb_motion_notify_event_t *e = (xcb_motion_notify_event_t *)arg;
	xcb_query_pointer_reply_t *p = w_query_pointer();
	
	uint32_t vals[2];
	vals[0] = p->root_x - x;
	vals[1] = p->root_y - y;
	update_geometry(stack[curws].fwin, MOVE_MASK, vals);

	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x63be(%rip), %r14      # 0xda70
movslq (%r14), %rax
imulq $0x50, %rax, %rax
leaq 0x6270(%rip), %r15      # 0xd930
movq 0x48(%r15,%rax), %rax
cmpl $0x7, 0x178(%rax)
jne 0x7711
xorl %eax, %eax
callq 0x372c
movq %rax, %rbx
movswl 0x10(%rax), %eax
subl 0x63a2(%rip), %eax      # 0xda84
leaq -0x20(%rbp), %rdx
movl %eax, (%rdx)
movswl 0x12(%rbx), %eax
subl 0x6396(%rip), %eax      # 0xda88
movl %eax, 0x4(%rdx)
movslq (%r14), %rax
imulq $0x50, %rax, %rax
movq 0x48(%r15,%rax), %rdi
pushq $0x3
popq %rsi
callq 0x5243
movq %rbx, %rdi
callq 0x3270
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_south_east
static void mouse_resize_motion_south_east(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();

	uint32_t vals[2];
	vals[0] = p->root_x + x;
	vals[1] = p->root_y + y;
	update_geometry(stack[curws].fwin, RESIZE_MASK, vals);
	
	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x372c
movq %rax, %rbx
movswl 0x10(%rax), %eax
addl 0x6326(%rip), %eax      # 0xda84
leaq -0x10(%rbp), %rdx
movl %eax, (%rdx)
movswl 0x12(%rbx), %eax
addl 0x631a(%rip), %eax      # 0xda88
movl %eax, 0x4(%rdx)
leaq 0x62f8(%rip), %rax      # 0xda70
movslq (%rax), %rax
imulq $0x50, %rax, %rax
leaq 0x61aa(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
pushq $0xc
popq %rsi
callq 0x5243
movq %rbx, %rdi
callq 0x3270
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_south
static void mouse_resize_motion_south(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();

	uint32_t vals[1];
	vals[0] = p->root_y + y;
	update_geometry(stack[curws].fwin, XCB_CONFIG_WINDOW_HEIGHT, vals);
	
	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x372c
movq %rax, %rbx
movswl 0x12(%rax), %eax
addl 0x62cc(%rip), %eax      # 0xda88
leaq -0xc(%rbp), %rdx
movl %eax, (%rdx)
leaq 0x62a7(%rip), %rax      # 0xda70
movslq (%rax), %rax
imulq $0x50, %rax, %rax
leaq 0x6159(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
pushq $0x8
popq %rsi
callq 0x5243
movq %rbx, %rdi
callq 0x3270
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_north
static void mouse_resize_motion_north(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();

	uint32_t vals[2];
	vals[0] = p->root_y - y;
	vals[1] = south - p->root_y + y;
	update_geometry(stack[curws].fwin, XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_HEIGHT, vals);
	
	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x372c
movq %rax, %rbx
movswl 0x12(%rax), %eax
movl 0x627b(%rip), %ecx      # 0xda88
movl %eax, %esi
subl %ecx, %esi
leaq -0x10(%rbp), %rdx
movl %esi, (%rdx)
subl %eax, %ecx
addl 0x626d(%rip), %ecx      # 0xda8c
movl %ecx, 0x4(%rdx)
leaq 0x6247(%rip), %rax      # 0xda70
movslq (%rax), %rax
imulq $0x50, %rax, %rax
leaq 0x60f9(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
pushq $0xa
popq %rsi
callq 0x5243
movq %rbx, %rdi
callq 0x3270
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_west
static void mouse_resize_motion_west(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();

	uint32_t vals[2];
	vals[0] = p->root_x - x;
	vals[1] = east - p->root_x + x;	

	update_geometry(stack[curws].fwin, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_WIDTH, vals);
	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x372c
movq %rax, %rbx
movswl 0x10(%rax), %eax
movl 0x6217(%rip), %ecx      # 0xda84
movl %eax, %esi
subl %ecx, %esi
leaq -0x10(%rbp), %rdx
movl %esi, (%rdx)
subl %eax, %ecx
addl 0x6211(%rip), %ecx      # 0xda90
movl %ecx, 0x4(%rdx)
leaq 0x61e7(%rip), %rax      # 0xda70
movslq (%rax), %rax
imulq $0x50, %rax, %rax
leaq 0x6099(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
pushq $0x5
popq %rsi
callq 0x5243
movq %rbx, %rdi
callq 0x3270
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_east
static void mouse_resize_motion_east(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();

	uint32_t vals[1];
	vals[0] = p->root_x + x;

	update_geometry(stack[curws].fwin, XCB_CONFIG_WINDOW_WIDTH, vals);
	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x372c
movq %rax, %rbx
movswl 0x10(%rax), %eax
addl 0x61b7(%rip), %eax      # 0xda84
leaq -0xc(%rbp), %rdx
movl %eax, (%rdx)
leaq 0x6196(%rip), %rax      # 0xda70
movslq (%rax), %rax
imulq $0x50, %rax, %rax
leaq 0x6048(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
pushq $0x4
popq %rsi
callq 0x5243
movq %rbx, %rdi
callq 0x3270
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_north_west
static void mouse_resize_motion_north_west(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();
	uint32_t vals[4];
	vals[0] = p->root_x - x;
	vals[1] = p->root_y - y;
	vals[2] = east - p->root_x + x;	
	vals[3] = south - p->root_y + y;
	free(p);

	update_geometry(stack[curws].fwin, MOVE_RESIZE_MASK, vals);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorl %eax, %eax
callq 0x372c
movswl 0x10(%rax), %ecx
movl 0x6166(%rip), %edx      # 0xda84
movl %ecx, %esi
subl %edx, %esi
leaq -0x20(%rbp), %rbx
movl %esi, (%rbx)
movswl 0x12(%rax), %esi
movl 0x6156(%rip), %edi      # 0xda88
movl %esi, %r8d
subl %edi, %r8d
movl %r8d, 0x4(%rbx)
subl %ecx, %edx
addl 0x614c(%rip), %edx      # 0xda90
movl %edx, 0x8(%rbx)
subl %esi, %edi
addl 0x613d(%rip), %edi      # 0xda8c
movl %edi, 0xc(%rbx)
movq %rax, %rdi
callq 0x3270
leaq 0x610f(%rip), %rax      # 0xda70
movslq (%rax), %rax
imulq $0x50, %rax, %rax
leaq 0x5fc1(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
pushq $0xf
popq %rsi
movq %rbx, %rdx
callq 0x5243
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_north_east
static void mouse_resize_motion_north_east(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();
	uint32_t vals[3];
	vals[0] = p->root_y - y;
	vals[1] = p->root_x + x;
	vals[2] = south - p->root_y + y;
	free(p);

	update_geometry(stack[curws].fwin, XCB_CONFIG_WINDOW_Y | RESIZE_MASK, vals);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorl %eax, %eax
callq 0x372c
movswl 0x12(%rax), %ecx
movl 0x60e8(%rip), %edx      # 0xda88
movl %ecx, %esi
subl %edx, %esi
leaq -0x14(%rbp), %rbx
movl %esi, (%rbx)
movswl 0x10(%rax), %esi
addl 0x60d0(%rip), %esi      # 0xda84
movl %esi, 0x4(%rbx)
subl %ecx, %edx
addl 0x60cd(%rip), %edx      # 0xda8c
movl %edx, 0x8(%rbx)
movq %rax, %rdi
callq 0x3270
leaq 0x609f(%rip), %rax      # 0xda70
movslq (%rax), %rax
imulq $0x50, %rax, %rax
leaq 0x5f51(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
pushq $0xe
popq %rsi
movq %rbx, %rdx
callq 0x5243
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_motion_south_west
static void mouse_resize_motion_south_west(void *arg) {
	xcb_query_pointer_reply_t *p = w_query_pointer();
	uint32_t vals[3];
	vals[0] = p->root_x - x;
	vals[1] = east - p->root_x + x;
	vals[2] = p->root_y + y;
	free(p);

	update_geometry(stack[curws].fwin, XCB_CONFIG_WINDOW_X | RESIZE_MASK, vals);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorl %eax, %eax
callq 0x372c
movswl 0x10(%rax), %ecx
movl 0x6074(%rip), %edx      # 0xda84
movl %ecx, %esi
subl %edx, %esi
leaq -0x14(%rbp), %rbx
movl %esi, (%rbx)
subl %ecx, %edx
addl 0x606e(%rip), %edx      # 0xda90
movl %edx, 0x4(%rbx)
movswl 0x12(%rax), %ecx
addl 0x6059(%rip), %ecx      # 0xda88
movl %ecx, 0x8(%rbx)
movq %rax, %rdi
callq 0x3270
leaq 0x602f(%rip), %rax      # 0xda70
movslq (%rax), %rax
imulq $0x50, %rax, %rax
leaq 0x5ee1(%rip), %rcx      # 0xd930
movq 0x48(%rcx,%rax), %rdi
pushq $0xd
popq %rsi
movq %rbx, %rdx
callq 0x5243
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/snap.c
// Function: snap
void snap(int index) {
	if (!stack[curws].fwin || stack[curws].fwin->is_e_full || stack[curws].fwin->is_i_full) {
		return;
	}

	if (index == stack[curws].fwin->snap_index) {
		snap_restore_state(stack[curws].fwin);
		return;
	}

	if (stack[curws].fwin->snap_index == SNAP_NONE) {
		snap_save_state(stack[curws].fwin, index);
	} else {
		stack[curws].fwin->snap_index = index;
	}

	update_geometry(stack[curws].fwin, MOVE_RESIZE_MASK, snap_regions[index]);

	if (state == MOVE) {
		return;
	}

	safe_raise(stack[curws].fwin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x5f17(%rip), %r15      # 0xda70
movslq (%r15), %rax
imulq $0x50, %rax, %rax
leaq 0x5dc9(%rip), %r12      # 0xd930
movq 0x48(%r12,%rax), %r14
testq %r14, %r14
je 0x7b85
cmpl $0x0, 0x190(%r14)
jne 0x7b85
cmpl $0x0, 0x18c(%r14)
je 0x7b8e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %edi, %ebx
movl 0x178(%r14), %eax
cmpl %edi, %eax
jne 0x7bab
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7b27
movq %r14, %rdi
cmpl $0x7, %eax
jne 0x7bce
leaq 0x168(%r14), %rsi
movq %r14, %rdi
callq 0x51d7
movslq (%r15), %rax
imulq $0x50, %rax, %rax
movq 0x48(%r12,%rax), %rdi
movl %ebx, 0x178(%r14)
movslq %ebx, %rax
shlq $0x4, %rax
leaq 0x5ebd(%rip), %rdx      # 0xdaa0
addq %rax, %rdx
pushq $0xf
popq %rsi
callq 0x5243
leaq 0x584f(%rip), %rax      # 0xd444
cmpl $0x1, (%rax)
je 0x7b85
movslq (%r15), %rax
imulq $0x50, %rax, %rax
movq 0x48(%r12,%rax), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4db7
nop
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/margin.c
// Function: create_margin_window
static void create_margin_window(int i) {
	margins[i].win = xcb_generate_id(conn);
	uint32_t mask = XCB_CW_EVENT_MASK;
	uint32_t val = XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW;
	xcb_create_window(conn, XCB_COPY_FROM_PARENT, margins[i].win, scr->root, 0, 0,
			scr->width_in_pixels, scr->height_in_pixels, 0,
			XCB_WINDOW_CLASS_INPUT_ONLY, XCB_COPY_FROM_PARENT, mask, &val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edi, %ebx
leaq 0x566a(%rip), %r14      # 0xd448
movq (%r14), %rdi
callq 0x3550
movslq %ebx, %rcx
imulq $0x1c, %rcx, %rcx
leaq 0x556c(%rip), %rdx      # 0xd360
movl %eax, 0x14(%rcx,%rdx)
leaq -0x14(%rbp), %rdx
movl $0x30, (%rdx)
movq (%r14), %rdi
leaq 0x5644(%rip), %rcx      # 0xd450
movq (%rcx), %rsi
movl (%rsi), %ecx
movzwl 0x14(%rsi), %r8d
movzwl 0x16(%rsi), %esi
movq %rdx, 0x30(%rsp)
movl %esi, 0x8(%rsp)
andl $0x0, 0x20(%rsp)
movl %r8d, (%rsp)
andl $0x0, 0x10(%rsp)
movl $0x800, 0x28(%rsp)      # imm = 0x800
movl $0x2, 0x18(%rsp)
xorl %esi, %esi
movl %eax, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3030
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/margin.c
// Function: margin_event_helper
void margin_event_helper(xcb_generic_event_t *ev, void (*func)(int)) {
	if (state != MOVE) {
		return;
	}
	
	xcb_enter_notify_event_t *e = (xcb_enter_notify_event_t *)ev;

	for (int i = 0; i < LEN(margins); i++) {
		if (e->event == margins[i].win) {
			func(i);
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x550f(%rip), %rax      # 0xd444
cmpl $0x1, (%rax)
jne 0x7f59
movl 0xc(%rdi), %eax
leaq 0x5430(%rip), %rcx      # 0xd374
xorl %edi, %edi
cmpq $0x7, %rdi
je 0x7f59
cmpl (%rcx), %eax
je 0x7f5b
incq %rdi
addq $0x1c, %rcx
jmp 0x7f46
popq %rbp
retq
popq %rbp
jmpq *%rsi
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/color.c
// Function: hex_to_rgb
XRenderColor hex_to_rgb(uint32_t hex) {
	rgba col;
	col.v = xcb_color(hex);

	XRenderColor ret;
	ret.red = col.r * 65535 / 255;
	ret.green = col.g * 65535 / 255;
	ret.blue = col.b * 65535 / 255;
	ret.alpha = col.a * 65535 / 255;

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
cmpl $0x1000000, %edi        # imm = 0x1000000
jb 0x805c
movl %edi, %r9d
shrl $0x18, %r9d
movl %edi, %eax
shrl $0x10, %eax
movl %edi, %esi
shrl $0x8, %esi
movl $0xff, %r8d
andl %r8d, %eax
imull %r9d, %eax
movw $0xff, %r10w
xorl %edx, %edx
divw %r10w
movl %eax, %ecx
andl %r8d, %esi
imull %r9d, %esi
movl %esi, %eax
xorl %edx, %edx
divw %r10w
movl %eax, %esi
movl %edi, %eax
andl %r8d, %eax
imull %r9d, %eax
xorl %edx, %edx
divw %r10w
movzwl %ax, %eax
andl $0xff000000, %edi       # imm = 0xFF000000
orl %eax, %edi
andl %r8d, %ecx
shll $0x10, %ecx
orl %edi, %ecx
shll $0x8, %esi
movzwl %si, %eax
orl %ecx, %eax
movl %eax, %edx
shrl $0x10, %edx
movl %eax, %ecx
shrl $0x18, %ecx
movl $0xff, %esi
andl %esi, %edx
imull $0x101, %edx, %edi      # imm = 0x101
movzbl %ah, %edx
andl %esi, %eax
imull $0x101, %eax, %esi      # imm = 0x101
imull $0x101, %ecx, %eax      # imm = 0x101
shlq $0x30, %rax
shlq $0x20, %rsi
orq %rax, %rsi
imull $0x1010000, %edx, %eax  # imm = 0x1010000
orq %rsi, %rax
orq %rdi, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kaiserschmarrn0[P]mywm/color.c
// Function: xft_color
XftColor xft_color(uint32_t hex) {
	XRenderColor rc = hex_to_rgb(hex);

	XftColor ret;
	XftColorAllocValue(dpy, vis_ptr, cm, &rc, &ret);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
callq 0x7fe8
leaq -0x10(%rbp), %rcx
movq %rax, (%rcx)
leaq 0x53e7(%rip), %rax      # 0xd4a0
movq (%rax), %rdi
leaq 0x53ed(%rip), %rax      # 0xd4b0
movq (%rax), %rsi
leaq 0x53ef(%rip), %rax      # 0xd4bc
movl (%rax), %edx
leaq -0x20(%rbp), %rbx
movq %rbx, %r8
callq 0x3440
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/oil_resample.c
// Function: oil_scale_free
void oil_scale_free(struct oil_scale *os)
{
	if (!os) {
		return;
	}

	free(os->rb);
	os->rb = NULL;
	free(os->coeffs_y);
	os->coeffs_y = NULL;
	free(os->coeffs_x);
	os->coeffs_x = NULL;
	free(os->borders_x);
	os->borders_x = NULL;
	free(os->borders_y);
	os->borders_y = NULL;
	free(os->sums_y);
	os->sums_y = NULL;
	free(os->tmp_coeffs);
	os->tmp_coeffs = NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x1677
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
callq 0x1030
andq $0x0, 0x48(%rbx)
movq 0x20(%rbx), %rdi
callq 0x1030
andq $0x0, 0x20(%rbx)
movq 0x28(%rbx), %rdi
callq 0x1030
andq $0x0, 0x28(%rbx)
movq 0x30(%rbx), %rdi
callq 0x1030
andq $0x0, 0x30(%rbx)
movq 0x38(%rbx), %rdi
callq 0x1030
andq $0x0, 0x38(%rbx)
movq 0x40(%rbx), %rdi
callq 0x1030
andq $0x0, 0x40(%rbx)
movq 0x50(%rbx), %rdi
callq 0x1030
andq $0x0, 0x50(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/oil_resample.c
// Function: set_coeffs
static void set_coeffs(int in_dim, int out_dim, float *coeffs, int *borders,
	float *tmp)
{
	if (out_dim <= in_dim) {
		xscale_calc_coeffs(in_dim, out_dim, coeffs, borders, tmp);
	} else {
		scale_up_coeffs(in_dim, out_dim, coeffs, borders);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, 0x48(%rsp)
movq %rcx, 0x58(%rsp)
movq %rdx, 0x18(%rsp)
movl %edi, %r15d
cmpl %edi, %esi
movq %r15, 0x50(%rsp)
jle 0x172e
leal -0x1(%r15), %r14d
xorl %r15d, %r15d
testl %esi, %esi
movl $0x0, %r13d
movl %esi, %ebp
cmovgl %esi, %r13d
xorl %r12d, %r12d
cmpl %r12d, %r13d
je 0x1894
movq 0x50(%rsp), %rbx
movl %ebx, %edi
movl %ebp, %esi
movl %r12d, %edx
leaq 0x30(%rsp), %rcx
callq 0x2d25
leal 0x2(%rax), %ecx
movl %ecx, %esi
subl %r14d, %esi
movl %r14d, %edi
cmovll %ecx, %edi
pushq $0x1
popq %rdx
subl %eax, %edx
testl %eax, %eax
cmovgl %r15d, %edx
cmpl %ebx, %ecx
cmovll %r15d, %esi
movslq %edi, %rax
movq 0x58(%rsp), %rcx
incl (%rcx,%rax,4)
movslq %esi, %rcx
movq 0x18(%rsp), %rbx
leaq (%rbx,%rcx,4), %rdi
movss 0x30(%rsp), %xmm0
pushq $0x4
popq %rsi
callq 0x2d83
addq $0x10, %rbx
movq %rbx, 0x18(%rsp)
incl %r12d
jmp 0x16bd
leal (,%r15,4), %eax
cltd
idivl %esi
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x174b
orl $-0x1, 0x30(%rsp,%rcx,4)
incq %rcx
jmp 0x173b
movl %eax, %ecx
andl $-0x2, %ecx
movl %ecx, 0xc(%rsp)
sarl %eax
movl %eax, 0x24(%rsp)
testl %esi, %esi
movl $0x0, %eax
cmovgl %esi, %eax
movq %rax, 0x60(%rsp)
leal -0x1(%r15), %eax
movl %eax, 0x20(%rsp)
xorl %edx, %edx
movl %esi, 0x28(%rsp)
cmpq 0x60(%rsp), %rdx
je 0x1894
movl %r15d, %edi
leaq 0x2c(%rsp), %rcx
movq %rdx, 0x10(%rsp)
callq 0x2d25
movl %eax, %r14d
movl 0x24(%rsp), %ecx
subl %ecx, %r14d
leal 0x1(%r14), %ebx
addl %ecx, %eax
cmpl %r15d, %eax
cmovgel 0x20(%rsp), %eax
movq 0x10(%rsp), %rbp
andl $0x3, %ebp
movl %ebp, %ecx
movl %eax, 0x30(%rsp,%rcx,4)
movq 0x10(%rsp), %rcx
decl %ecx
andl $0x3, %ecx
movl 0x30(%rsp,%rcx,4), %r15d
movl %r14d, %r12d
movl 0xc(%rsp), %ecx
addl %ecx, %r14d
movl %ecx, %esi
subl %eax, %r14d
subl %r15d, %eax
movq 0x58(%rsp), %rcx
movq 0x10(%rsp), %rdx
movl %eax, (%rcx,%rdx,4)
notl %r12d
movl %ebx, %r13d
sarl $0x1f, %r13d
andl %r12d, %r13d
movss 0x2c(%rsp), %xmm0
movq 0x48(%rsp), %rdi
movl %r13d, %edx
movl %r14d, %ecx
callq 0x2d83
movq 0x10(%rsp), %rdx
pushq $0x1
popq %r9
movl 0xc(%rsp), %eax
subl %r14d, %eax
movq 0x18(%rsp), %r8
xorq $0x2, %rbp
incq %rdx
movl %edx, %ecx
andl $0x3, %ecx
movq 0x48(%rsp), %rsi
leaq (%rsi,%r13,4), %r10
testl %ebx, %ebx
movl $0x0, %esi
cmovlel %esi, %ebx
leal (,%rbx,4), %esi
leal (%r12,%rbx), %edi
cmpl %edi, %eax
jle 0x1886
xorl %edi, %edi
cmpl %r15d, %ebx
jg 0x186b
movl %r9d, %edi
cmpl 0x30(%rsp,%rbp,4), %ebx
jg 0x186b
xorl %edi, %edi
cmpl 0x30(%rsp,%rcx,4), %ebx
setg %dil
xorl $0x3, %edi
movss (%r10), %xmm0
addl %esi, %edi
movslq %edi, %rdi
movss %xmm0, (%r8,%rdi,4)
addq $0x4, %r10
addl $0x4, %esi
incl %ebx
jmp 0x1846
movl 0x28(%rsp), %esi
movq 0x50(%rsp), %r15
jmp 0x1777
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/oil_resample.c
// Function: oil_scale_slots
int oil_scale_slots(struct oil_scale *ys)
{
	if (ys->out_height <= ys->in_height) {
		return ys->borders_y[ys->out_pos];
	}
	if (ys->in_pos) {
		return ys->borders_y[ys->in_pos - 1] == 0;
	}
	return ys->borders_y[0] == 0 ? 2 : 1;
}

// Assembly:
movl 0x4(%rdi), %eax
cmpl (%rdi), %eax
jle 0x18c8
movslq 0x14(%rdi), %rdx
movq 0x38(%rdi), %rcx
xorl %eax, %eax
testq %rdx, %rdx
je 0x18d4
cmpl $0x0, -0x4(%rcx,%rdx,4)
sete %al
retq
movq 0x38(%rdi), %rax
movslq 0x18(%rdi), %rcx
movl (%rax,%rcx,4), %eax
retq
cmpl $0x1, (%rcx)
adcl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/oil_resample.c
// Function: oil_fix_ratio
int oil_fix_ratio(int src_width, int src_height, int *out_width,
	int *out_height)
{
	double width_ratio, height_ratio, tmp;
	int *adjust_dim;

	if (src_width < 1 || src_height < 1 || *out_width < 1 || *out_height < 1) {
		return -1; // bad argument
	}

	width_ratio = *out_width / (double)src_width;
	height_ratio = *out_height / (double)src_height;
	if (width_ratio < height_ratio) {
		tmp = round(width_ratio * src_height);
		adjust_dim = out_height;
	} else {
		tmp = round(height_ratio * src_width);
		adjust_dim = out_width;
	}
	if (tmp > INT_MAX) {
		return -2; // adjusted dimension out of range
	}
	*adjust_dim = tmp ? tmp : 1;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
testl %edi, %edi
setle %al
testl %esi, %esi
setle %cl
orb %al, %cl
pushq $-0x1
popq %rax
jne 0x2d1d
movq %rdx, %rbx
movl (%rdx), %ecx
testl %ecx, %ecx
jle 0x2d1d
movl (%r14), %edx
testl %edx, %edx
jle 0x2d1d
cvtsi2sd %ecx, %xmm0
cvtsi2sd %edi, %xmm1
divsd %xmm1, %xmm0
cvtsi2sd %edx, %xmm3
cvtsi2sd %esi, %xmm2
divsd %xmm2, %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm0, %xmm2
movsd %xmm0, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
cmpltsd %xmm3, %xmm0
andpd %xmm0, %xmm2
andnpd %xmm1, %xmm0
orpd %xmm2, %xmm0
callq 0x1040
ucomisd 0x2383(%rip), %xmm0     # 0x5060
jbe 0x2ce4
pushq $-0x2
popq %rax
jmp 0x2d1d
movsd 0x8(%rsp), %xmm1
ucomisd 0x10(%rsp), %xmm1
cmovaq %r14, %rbx
xorpd %xmm1, %xmm1
cmpneqsd %xmm0, %xmm1
movapd %xmm1, %xmm2
andpd %xmm0, %xmm2
movsd 0x235b(%rip), %xmm0     # 0x5068
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/oil_resample.c
// Function: split_map
static int split_map(int dim_in, int dim_out, int pos, float *rest)
{
	double smp;
	int smp_i;

	smp = map(dim_in, dim_out, pos);
	smp_i = smp < 0 ? -1 : smp;
	*rest = smp - smp_i;
	return smp_i;
}

// Assembly:
cvtsi2sd %edx, %xmm0
addsd 0x2307(%rip), %xmm0     # 0x5038
cvtsi2sd %edi, %xmm1
cvtsi2sd %esi, %xmm2
divsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
addsd 0x2327(%rip), %xmm1     # 0x5070
xorpd %xmm0, %xmm0
movapd %xmm1, %xmm2
cmpltsd %xmm0, %xmm2
movsd 0x231a(%rip), %xmm0     # 0x5078
andpd %xmm2, %xmm0
andnpd %xmm1, %xmm2
orpd %xmm2, %xmm0
cvttsd2si %xmm0, %eax
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
subsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movss %xmm0, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/oil_resample.c
// Function: calc_coeffs
static void calc_coeffs(float *coeffs, float tx, int taps, int ltrim, int rtrim)
{
	int i;
	float tmp, tap_mult, fudge;

	tap_mult = (float)taps / TAPS;
	tx = 1 - tx - taps / 2 + ltrim;
	fudge = 0.0f;

	for (i=ltrim; i<taps-rtrim; i++) {
		tmp = catrom(fabsf(tx) / tap_mult) / tap_mult;
		fudge += tmp;
		coeffs[i] = tmp;
		tx += 1;
	}
	fudge = 1 / fudge;
	for (i=ltrim; i<taps-rtrim; i++) {
		coeffs[i] *= fudge;
	}
}

// Assembly:
movl %edx, %r8d
cvtsi2ss %esi, %xmm2
mulss 0x230a(%rip), %xmm2     # 0x509c
movss 0x22f2(%rip), %xmm1     # 0x508c
movaps %xmm1, %xmm3
subss %xmm0, %xmm3
pushq $0x2
popq %r9
movl %esi, %eax
cltd
idivl %r9d
cvtsi2ss %eax, %xmm0
subss %xmm0, %xmm3
cvtsi2ss %r8d, %xmm0
addss %xmm3, %xmm0
subl %ecx, %esi
movl %r8d, %eax
leaq (%rdi,%rax,4), %rcx
xorps %xmm3, %xmm3
movaps 0x2321(%rip), %xmm4     # 0x50f0
movss 0x22d5(%rip), %xmm5     # 0x50ac
movss 0x22d1(%rip), %xmm6     # 0x50b0
movss 0x22b9(%rip), %xmm7     # 0x50a0
movss 0x22b4(%rip), %xmm8     # 0x50a4
movss 0x22af(%rip), %xmm9     # 0x50a8
movss 0x228e(%rip), %xmm10    # 0x5090
movl %r8d, %edx
cmpl %edx, %esi
jle 0x2e78
movaps %xmm0, %xmm12
andps %xmm4, %xmm12
divss %xmm2, %xmm12
ucomiss %xmm12, %xmm1
jbe 0x2e3b
movaps %xmm12, %xmm11
mulss %xmm5, %xmm11
addss %xmm6, %xmm11
mulss %xmm12, %xmm11
mulss %xmm12, %xmm11
addss %xmm1, %xmm11
jmp 0x2e5d
movaps %xmm7, %xmm11
subss %xmm12, %xmm11
mulss %xmm12, %xmm11
addss %xmm8, %xmm11
mulss %xmm12, %xmm11
addss %xmm9, %xmm11
mulss %xmm10, %xmm11
divss %xmm2, %xmm11
addss %xmm11, %xmm3
movss %xmm11, (%rcx)
addss %xmm1, %xmm0
addq $0x4, %rcx
incl %edx
jmp 0x2e05
divss %xmm3, %xmm1
leaq (%rdi,%rax,4), %rax
cmpl %r8d, %esi
jle 0x2e9a
movss (%rax), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%rax)
addq $0x4, %rax
incl %r8d
jmp 0x2e80
retq
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/oil_resample.c
// Function: dump_out
static void dump_out(float *out, float sum[][4], int n)
{
	int i;
	for (i=0; i<n; i++) {
		out[i] = sum[i][0];
		shift_left_f(sum[i]);
	}
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
shlq $0x2, %rdx
cmpq %rax, %rdx
je 0x2ef8
movss (%rsi,%rax,4), %xmm0
movss %xmm0, (%rdi,%rax)
movsd 0x4(%rsi,%rax,4), %xmm0
movsd %xmm0, (%rsi,%rax,4)
movss 0xc(%rsi,%rax,4), %xmm0
movss %xmm0, 0x8(%rsi,%rax,4)
andl $0x0, 0xc(%rsi,%rax,4)
addq $0x4, %rax
jmp 0x2ec7
retq
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/oil_resample.c
// Function: xscale_up_reduce_n
static void xscale_up_reduce_n(float in[][4], float *out, float *coeffs,
	int cmp)
{
	int i;

	for (i=0; i<cmp; i++) {
		out[i] = in[i][0] * coeffs[0] +
			in[i][1] * coeffs[1] +
			in[i][2] * coeffs[2] +
			in[i][3] * coeffs[3];
	}
}

// Assembly:
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
shlq $0x2, %rcx
cmpq %rax, %rcx
je 0x2f4a
movss (%rdi,%rax,4), %xmm0
movss 0x4(%rdi,%rax,4), %xmm1
mulss 0x4(%rdx), %xmm1
mulss (%rdx), %xmm0
movss 0x8(%rdi,%rax,4), %xmm2
mulss 0x8(%rdx), %xmm2
addss %xmm1, %xmm0
movss 0xc(%rdi,%rax,4), %xmm1
mulss 0xc(%rdx), %xmm1
addss %xmm0, %xmm2
addss %xmm2, %xmm1
movss %xmm1, (%rsi,%rax)
addq $0x4, %rax
jmp 0x2f04
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/test.c
// Function: main
int main()
{
	int t = 1531289551;
	//int t = time(NULL);
	printf("seed: %d\n", t);
	srand(t);
	oil_global_init();
	test_scale_all();
	test_scale_catrom_extremes();
	printf("worst error: %Lf\n", worst);
	printf("All tests pass.\n");
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x2286(%rip), %rdi      # 0x51e0
movl $0x5b459fcf, %esi       # imm = 0x5B459FCF
xorl %eax, %eax
callq 0x1090
movl $0x5b459fcf, %edi       # imm = 0x5B459FCF
callq 0x10b0
callq 0x121c
pushq $0x5
popq %rdi
pushq $0x1
popq %rbx
movq %rbx, %rsi
callq 0x3041
pushq $0x8
popq %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3041
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x3041
pushq $0x64
popq %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3041
pushq $0x63
popq %rsi
movq %r14, %rdi
callq 0x3041
pushq $0x2
popq %rdi
movq %rbx, %rsi
callq 0x3041
pushq $0x4
popq %rbx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3166
movq %rax, %r14
movq (%rax), %rax
andl $0x0, (%rax)
movq 0x8(%r14), %rax
movl $0xffff00, %ecx         # imm = 0xFFFF00
movl %ecx, (%rax)
movq 0x10(%r14), %rax
movl %ecx, (%rax)
movq 0x18(%r14), %rax
andl $0x0, (%rax)
pushq $0x7
popq %rcx
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %rcx, %r8
callq 0x31b3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b91
fldt 0xc8b6(%rip)            # 0xf8d0
fstpt (%rsp)
leaq 0x21c6(%rip), %rdi      # 0x51ea
xorl %eax, %eax
callq 0x1090
leaq 0x227c(%rip), %rdi      # 0x52ae
callq 0x1050
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/test.c
// Function: test_scale_each_cs
static void test_scale_each_cs(long dim_a, long dim_b)
{
	test_scale_square_rand(dim_a, dim_b, OIL_CS_G);
	test_scale_square_rand(dim_a, dim_b, OIL_CS_GA);
	test_scale_square_rand(dim_a, dim_b, OIL_CS_RGB);
	test_scale_square_rand(dim_a, dim_b, OIL_CS_RGBA);
	test_scale_square_rand(dim_a, dim_b, OIL_CS_CMYK);
	test_scale_square_rand(dim_a, dim_b, OIL_CS_RGBX);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdx
callq 0x30bf
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30bf
pushq $0x3
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30bf
movq %r14, %rdi
movq %rbx, %rsi
movl $0x104, %edx            # imm = 0x104
callq 0x30bf
movq %r14, %rdi
movq %rbx, %rsi
movl $0x204, %edx            # imm = 0x204
callq 0x30bf
pushq $0x4
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x30bf
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/test.c
// Function: test_scale_square_rand
static void test_scale_square_rand(long in_dim, long out_dim,
	enum oil_colorspace cs)
{
	long i, in_row_stride;
	unsigned char **input_image;

	in_row_stride = OIL_CMP(cs) * in_dim;

	/* Allocate & populate input image */
	input_image = alloc_2d_uchar(in_row_stride, in_dim);
	for (i=0; i<in_dim; i++) {
		fill_rand8(input_image[i], in_row_stride);
	}
	test_scale(in_dim, in_dim, input_image, out_dim, out_dim, cs);
	free_2d_uchar(input_image, in_dim);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
movzbl %dl, %r12d
imulq %rdi, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3166
movq %rax, %r15
xorl %r13d, %r13d
testq %r12, %r12
cmovleq %r13, %r12
testq %rbx, %rbx
movl $0x0, %ebp
movq %rbx, 0x10(%rsp)
cmovgq %rbx, %rbp
cmpq %rbp, %r13
je 0x312d
movq (%r15,%r13,8), %r14
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x3128
callq 0x1110
movb %al, (%r14,%rbx)
incq %rbx
jmp 0x3115
incq %r13
jmp 0x310a
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq 0x8(%rsp), %rcx
movq %rcx, %r8
movl 0x4(%rsp), %r9d
callq 0x31b3
movq %r15, %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3b91
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/test.c
// Function: alloc_2d_uchar
static unsigned char **alloc_2d_uchar(long width, long height)
{
	long i;
	unsigned char **rows;

	rows = malloc(height * sizeof(unsigned char*));
	for (i=0; i<height; i++) {
		rows[i] = malloc(width * sizeof(unsigned char));
	}
	return rows;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq (,%rsi,8), %rdi
callq 0x10f0
movq %rax, %r15
xorl %r12d, %r12d
testq %rbx, %rbx
cmovleq %r12, %rbx
cmpq %r12, %rbx
je 0x31a4
movq %r14, %rdi
callq 0x10f0
movq %rax, (%r15,%r12,8)
incq %r12
jmp 0x318e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/test.c
// Function: free_2d_uchar
static void free_2d_uchar(unsigned char **ptr, long height)
{
	int i;

	for (i=0; i<height; i++) {
		free(ptr[i]);
	}
	free(ptr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
testq %rsi, %rsi
cmovleq %r15, %r14
cmpq %r15, %r14
je 0x3bb9
movq (%rbx,%r15,8), %rdi
callq 0x1030
incq %r15
jmp 0x3ba6
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/test.c
// Function: alloc_2d_ld
static long double **alloc_2d_ld(long width, long height)
{
	long i;
	long double **rows;

	rows = malloc(height * sizeof(long double*));
	for (i=0; i<height; i++) {
		rows[i] = malloc(width * sizeof(long double));
	}
	return rows;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq (,%rsi,8), %rdi
callq 0x10f0
movq %rax, %r15
shlq $0x4, %r14
xorl %r12d, %r12d
testq %rbx, %rbx
cmovleq %r12, %rbx
cmpq %r12, %rbx
je 0x3c08
movq %r14, %rdi
callq 0x10f0
movq %rax, (%r15,%r12,8)
incq %r12
jmp 0x3bf2
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/test.c
// Function: free_2d_ld
static void free_2d_ld(long double **ptr, long height)
{
	int i;

	for (i=0; i<height; i++) {
		free(ptr[i]);
	}
	free(ptr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
testq %rsi, %rsi
cmovleq %r15, %r14
cmpq %r15, %r14
je 0x3c3f
movq (%rbx,%r15,8), %rdi
callq 0x1030
incq %r15
jmp 0x3c2c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/ender672[P]liboil/test.c
// Function: linear_sample_to_srgb_reference
static long double linear_sample_to_srgb_reference(long double in_f)
{
	long double tmp;
	if (in_f <= 0.0L) {
		return 0.0L;
	}
	if (in_f >= 1.0L) {
		return 1.0L;
	}
	if (in_f <= 0.00313066844250063L) {
		return in_f * 12.92L;
	} else {
		tmp = powl(in_f, 1/2.4L);
		return 1.055L * tmp - 0.055L;
	}
}

// Assembly:
subq $0x28, %rsp
fldt 0x30(%rsp)
fldz
fucomi %st(1), %st
jae 0x4026
fstp %st(0)
fld1
fxch %st(1)
fucomi %st(1), %st
fxch %st(1)
jae 0x4026
fstp %st(0)
fldt 0x11ae(%rip)            # 0x51a0
fucompi %st(1), %st
jae 0x401a
fldt 0x11b4(%rip)            # 0x51b0
fstpt 0x10(%rsp)
fstpt (%rsp)
callq 0x1100
fldt 0x1152(%rip)            # 0x5160
fmulp %st, %st(1)
fldt 0x11aa(%rip)            # 0x51c0
faddp %st, %st(1)
jmp 0x4028
fldt 0x1120(%rip)            # 0x5140
fmulp %st, %st(1)
fldz
fxch %st(1)
fstp %st(1)
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: copyFileName
static 
void copyFileName ( Char* to, Char* from ) 
{
   if ( strlen(from) > FILE_NAME_LEN-10 )  {
      fprintf (
         stderr,
         "bzip2: file name\n`%s'\n"
         "is suspiciously (more than %d chars) long.\n"
         "Try using a reasonable file name instead.  Sorry! :-)\n",
         from, FILE_NAME_LEN-10
      );
      setExit(1);
      exit(exitValue);
   }

  strncpy(to,from,FILE_NAME_LEN-10);
  to[FILE_NAME_LEN-10]='\0';
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x10e0
cmpq $0x401, %rax            # imm = 0x401
jae 0x1d12
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1070
movb $0x0, 0x400(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x102df(%rip), %rax     # 0x11ff8
movq (%rax), %rdi
leaq 0xbeea(%rip), %rsi      # 0xdc0d
movq %rbx, %rdx
movl $0x400, %ecx            # imm = 0x400
xorl %eax, %eax
callq 0x1160
movl 0x11090(%rip), %edi     # 0x12dc8
testl %edi, %edi
jg 0x1d49
movl $0x1, 0x11082(%rip)     # 0x12dc8
pushq $0x1
popq %rdi
callq 0x1230
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: addFlagsFromEnvVar
static 
void addFlagsFromEnvVar ( Cell** argList, Char* varName ) 
{
   Int32 i, j, k;
   Char *envbase, *p;

   envbase = getenv(varName);
   if (envbase != NULL) {
      p = envbase;
      i = 0;
      while (True) {
         if (p[i] == 0) break;
         p += i;
         i = 0;
         while (isspace((Int32)(p[0]))) p++;
         while (p[i] != 0 && !isspace((Int32)(p[i]))) i++;
         if (i > 0) {
            k = i; if (k > FILE_NAME_LEN-10) k = FILE_NAME_LEN-10;
            for (j = 0; j < k; j++) tmpName[j] = p[j];
            tmpName[k] = 0;
            APPEND_FLAG(*argList, tmpName);
         }
      }
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1030
testq %rax, %rax
je 0x1e21
movq %rax, %r14
xorl %r13d, %r13d
movl $0x400, %r12d           # imm = 0x400
movl $0x400, %ebp            # imm = 0x400
leaq 0x11c9b(%rip), %r15     # 0x13a20
movl %r13d, %r13d
cmpb $0x0, (%r14,%r13)
je 0x1e21
callq 0x1270
movq (%rax), %rcx
leaq (%r14,%r13), %rax
incq %rax
addq %r13, %r14
decq %r14
movq %rax, %rdx
movsbq 0x1(%r14), %rsi
incq %r14
incq %rax
testb $0x20, 0x1(%rcx,%rsi,2)
jne 0x1da8
xorl %eax, %eax
xorl %r13d, %r13d
testb %sil, %sil
je 0x1de0
movsbq %sil, %rsi
testb $0x20, 0x1(%rcx,%rsi,2)
jne 0x1de0
movb (%rdx), %sil
decq %r13
incq %rdx
incq %rax
jmp 0x1dc2
negq %r13
jae 0x1d85
cmpq %r12, %rax
cmovaeq %r12, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x1e00
movb (%r14,%rcx), %dl
movb %dl, (%rcx,%r15)
incq %rcx
jmp 0x1dee
cmpl %ebp, %r13d
movl %r13d, %eax
cmovael %ebp, %eax
movb $0x0, (%rax,%r15)
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x1e30
movq %rax, (%rbx)
jmp 0x1d85
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: snocString
static 
Cell *snocString ( Cell *root, Char *name )
{
   if (root == NULL) {
      Cell *tmp = mkCell();
      tmp->name = (Char*) myMalloc ( 5 + strlen(name) );
      strcpy ( tmp->name, name );
      return tmp;
   } else {
      Cell *tmp = root;
      while (tmp->link != NULL) tmp = tmp->link;
      tmp->link = snocString ( tmp->link, name );
      return root;
   }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x1e5f
movq %rdi, %rbx
movq %rdi, %rax
movq %rax, %r15
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x1e43
xorl %edi, %edi
movq %r14, %rsi
callq 0x1e30
movq %rax, 0x8(%r15)
jmp 0x1e8d
pushq $0x10
popq %rdi
callq 0x387f
movq %rax, %rbx
andq $0x0, 0x8(%rax)
movq %r14, %rdi
callq 0x10e0
leal 0x5(%rax), %edi
callq 0x387f
movq %rax, (%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x1090
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: mySignalCatcher
static 
void mySignalCatcher ( IntNative n )
{
   fprintf ( stderr,
             "\n%s: Control-C or similar caught, quitting.\n",
             progName );
   cleanUpAndFail(1);
}

// Assembly:
pushq %rax
movq 0x100df(%rip), %rax     # 0x11ff8
movq (%rax), %rdi
movq 0x11add(%rip), %rdx     # 0x13a00
leaq 0xc493(%rip), %rsi      # 0xe3bd
xorl %eax, %eax
callq 0x1160
pushq $0x1
popq %rdi
callq 0x36e7
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: myMalloc
static 
void *myMalloc ( Int32 n )
{
   void* p;

   p = malloc ( (size_t)n );
   if (p == NULL) outOfMemory ();
   return p;
}

// Assembly:
pushq %rax
movslq %edi, %rdi
callq 0x1190
testq %rax, %rax
je 0x388f
popq %rcx
retq
callq 0x3894
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: outOfMemory
static 
void outOfMemory ( void )
{
   fprintf ( stderr,
             "\n%s: couldn't allocate enough memory\n",
             progName );
   showFileNames();
   cleanUpAndFail(1);
}

// Assembly:
pushq %rax
movq 0xe75c(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0x1015a(%rip), %rdx     # 0x13a00
leaq 0xa3d8(%rip), %rsi      # 0xdc85
xorl %eax, %eax
callq 0x1160
callq 0x36b7
pushq $0x1
popq %rdi
callq 0x36e7
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: panic
static 
void panic ( const Char* s )
{
   fprintf ( stderr,
             "\n%s: PANIC -- internal consistency error:\n"
             "\t%s\n"
             "\tThis is a BUG.  Please report it to me at:\n"
             "\tjseward@bzip.org\n",
             progName, s );
   showFileNames();
   cleanUpAndFail( 3 );
}

// Assembly:
pushq %rax
movq %rdi, %rcx
movq 0xe72c(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0x1012a(%rip), %rdx     # 0x13a00
leaq 0xac8a(%rip), %rsi      # 0xe567
xorl %eax, %eax
callq 0x1160
callq 0x36b7
pushq $0x3
popq %rdi
callq 0x36e7
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: fileExists
static 
Bool fileExists ( Char* name )
{
   FILE *tmp   = fopen ( name, "rb" );
   Bool exists = (tmp != NULL);
   if (tmp != NULL) fclose ( tmp );
   return exists;
}

// Assembly:
pushq %rbx
leaq 0xac3b(%rip), %rsi      # 0xe534
callq 0x1200
movq %rax, %rbx
testq %rax, %rax
je 0x390e
movq %rbx, %rdi
callq 0x10d0
testq %rbx, %rbx
setne %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: hasSuffix
static 
Bool hasSuffix ( Char* s, const Char* suffix )
{
   Int32 ns = strlen(s);
   Int32 nx = strlen(suffix);
   if (ns < nx) return False;
   if (strcmp(s + ns - nx, suffix) == 0) return True;
   return False;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x10e0
movq %rax, %r15
movq %rbx, %rdi
callq 0x10e0
cmpl %eax, %r15d
jge 0x393a
xorl %eax, %eax
jmp 0x3955
movslq %r15d, %rcx
addq %rcx, %r14
cltq
subq %rax, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1140
testl %eax, %eax
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: fopen_output_safely
static
FILE* fopen_output_safely ( Char* name, const char* mode )
{
#  if BZ_UNIX
   FILE*     fp;
   IntNative fh;
   fh = open(name, O_WRONLY|O_CREAT|O_EXCL, S_IWUSR|S_IRUSR);
   if (fh == -1) return NULL;
   fp = fdopen(fh, mode);
   if (fp == NULL) close(fh);
   return fp;
#  else
   return fopen(name, mode);
#  endif
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0xf7f4(%rip), %rdi      # 0x131e0
xorl %ebx, %ebx
movl $0xc1, %esi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x11e0
cmpl $-0x1, %eax
je 0x3a25
movl %eax, %ebp
leaq 0xab2a(%rip), %rsi      # 0xe537
movl %eax, %edi
callq 0x11c0
movq %rax, %rbx
testq %rax, %rax
jne 0x3a25
movl %ebp, %edi
callq 0x1110
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: pad
static 
void pad ( Char *s )
{
   Int32 i;
   if ( (Int32)strlen(s) >= longestFileName ) return;
   for (i = 1; i <= longestFileName - (Int32)strlen(s); i++)
      fprintf ( stderr, " " );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0xf392(%rip), %rdi      # 0x12dd0
callq 0x10e0
movl 0xffbe(%rip), %r12d     # 0x13a08
cmpl %eax, %r12d
jle 0x3a8a
pushq $0x1
popq %r14
leaq 0xf376(%rip), %rbx      # 0x12dd0
movq 0xe597(%rip), %r15      # 0x11ff8
pushq $0x20
popq %rbp
movq %rbx, %rdi
callq 0x10e0
subl %eax, %r12d
cmpl %r12d, %r14d
jg 0x3a8a
movq (%r15), %rsi
movl %ebp, %edi
callq 0x1120
incl %r14d
movl 0xff80(%rip), %r12d     # 0x13a08
jmp 0x3a64
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: applySavedTimeInfoToOutputFile
static 
void applySavedTimeInfoToOutputFile ( Char *dstName )
{
#  if BZ_UNIX
   IntNative      retVal;
   struct utimbuf uTimBuf;

   uTimBuf.actime = fileMetaInfo.st_atime;
   uTimBuf.modtime = fileMetaInfo.st_mtime;

   retVal = utime ( dstName, &uTimBuf );
   ERROR_IF_NOT_ZERO ( retVal );
#  endif
}

// Assembly:
subq $0x18, %rsp
movq 0x103da(%rip), %rax     # 0x13e78
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq 0x103db(%rip), %rax     # 0x13e88
movq %rax, 0x8(%rsi)
leaq 0xf728(%rip), %rdi      # 0x131e0
callq 0x1040
testl %eax, %eax
jne 0x3ac6
addq $0x18, %rsp
retq
callq 0x3acb
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: ioError
static 
void ioError ( void )
{
   fprintf ( stderr,
             "\n%s: I/O or other error, bailing out.  "
             "Possible reason follows.\n",
             progName );
   perror ( progName );
   showFileNames();
   cleanUpAndFail( 1 );
}

// Assembly:
pushq %rax
movq 0xe525(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xff23(%rip), %rdx      # 0x13a00
leaq 0xac2b(%rip), %rsi      # 0xe70f
xorl %eax, %eax
callq 0x1160
movq 0xff0e(%rip), %rdi      # 0x13a00
callq 0x1210
callq 0x36b7
pushq $0x1
popq %rdi
callq 0x36e7
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: uInt64_to_double
static
double uInt64_to_double ( UInt64* n )
{
   Int32  i;
   double base = 1.0;
   double sum  = 0.0;
   for (i = 0; i < 8; i++) {
      sum  += base * (double)(n->b[i]);
      base *= 256.0;
   }
   return sum;
}

// Assembly:
xorpd %xmm0, %xmm0
movsd 0x956d(%rip), %xmm1     # 0xd0c8
xorl %eax, %eax
movsd 0x9573(%rip), %xmm2     # 0xd0d8
cmpq $0x8, %rax
je 0x3b84
movzbl (%rdi,%rax), %ecx
cvtsi2sd %ecx, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm3, %xmm0
mulsd %xmm2, %xmm1
incq %rax
jmp 0x3b65
retq
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: uInt64_toAscii
static
void uInt64_toAscii ( char* outbuf, UInt64* n )
{
   Int32  i, q;
   UChar  buf[32];
   Int32  nBuf   = 0;
   UInt64 n_copy = *n;
   do {
      q = uInt64_qrm10 ( &n_copy );
      buf[nBuf] = q + '0';
      nBuf++;
   } while (!uInt64_isZero(&n_copy));
   outbuf[nBuf] = 0;
   for (i = 0; i < nBuf; i++) 
      outbuf[i] = buf[nBuf-i-1];
}

// Assembly:
movq (%rsi), %rax
movq %rax, -0x30(%rsp)
xorl %ecx, %ecx
movl $0x7, %esi
movl $0xa, %r8d
xorl %edx, %edx
movl %esi, %r9d
testl %r9d, %r9d
js 0x3bc1
shll $0x8, %edx
movl %r9d, %r10d
movzbl -0x30(%rsp,%r10), %eax
orl %edx, %eax
xorl %edx, %edx
divl %r8d
movb %al, -0x30(%rsp,%r10)
decl %r9d
jmp 0x3b9f
orb $0x30, %dl
movb %dl, -0x28(%rsp,%rcx)
leaq 0x1(%rcx), %rax
xorl %edx, %edx
cmpq $0x8, %rdx
je 0x3be4
cmpb $0x0, -0x30(%rsp,%rdx)
leaq 0x1(%rdx), %rdx
je 0x3bce
movq %rax, %rcx
jmp 0x3b9a
movl %eax, %eax
movb $0x0, (%rdi,%rax)
movslq %ecx, %rax
addq %rsp, %rax
addq $-0x28, %rax
movabsq $-0x1, %rdx
cmpq %rdx, %rcx
je 0x3c13
movb (%rax), %sil
movb %sil, 0x1(%rdi,%rdx)
incq %rdx
decq %rax
jmp 0x3bfe
retq
// File: /workspace/github_c_makefile_star2_O2/coapp-packages[P]bzip2/bzip2.c
// Function: crcError
static 
void crcError ( void )
{
   fprintf ( stderr,
             "\n%s: Data integrity error when decompressing.\n",
             progName );
   showFileNames();
   cadvise();
   cleanUpAndFail( 2 );
}

// Assembly:
pushq %rax
movq 0xe3a0(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xfd9e(%rip), %rdx      # 0x13a00
leaq 0xac2f(%rip), %rsi      # 0xe898
xorl %eax, %eax
callq 0x1160
callq 0x36b7
callq 0x3857
pushq $0x2
popq %rdi
callq 0x36e7