LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize
static int mouse_resize(press_arg *info) {
	xcb_get_geometry_reply_t *geom;

	if (!move_resize_helper(info->win, &geom)) {
		return 0;
	}

	events[XCB_ENTER_NOTIFY] = NULL;
	events[XCB_LEAVE_NOTIFY] = NULL;
	
	events[XCB_BUTTON_RELEASE] = (void (*)(xcb_generic_event_t *))resize_release;

	/*x = stack[curws].fwin->geom[GEOM_W] - info->event_x;
	y = stack[curws].fwin->geom[GEOM_H] - info->event_y;*/

	state = RESIZE;
	
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x18(%rbp), %rsi
callq 0x9700
cmpl $0x0, %eax
jne 0x98f9
movl $0x0, -0x4(%rbp)
jmp 0x993d
leaq 0x6bd0(%rip), %rax      # 0x104d0
movq $0x0, 0x38(%rax)
leaq 0x6bc1(%rip), %rax      # 0x104d0
movq $0x0, 0x40(%rax)
leaq 0x6bb2(%rip), %rax      # 0x104d0
leaq 0x7fb(%rip), %rcx       # 0xa120
movq %rcx, 0x28(%rax)
leaq 0x6b14(%rip), %rax      # 0x10444
movl $0x2, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_south
void mouse_resize_south(void *arg) {
	if (!mouse_resize((press_arg *)arg)) {
		return;
	}

	grab_pointer_cursor(resize_cursors[5]);
	
	mouse_resize_set_y_south((press_arg *)arg);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x98d0
cmpl $0x0, %eax
jne 0x9a4c
jmp 0x9a76
leaq 0x6ebd(%rip), %rax      # 0x10910
movl 0x14(%rax), %edi
callq 0x9480
movq -0x8(%rbp), %rdi
callq 0x9990
leaq 0x6a65(%rip), %rax      # 0x104d0
leaq 0xe(%rip), %rcx         # 0x9a80
movq %rcx, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_north
void mouse_resize_north(void *arg) {
	if (!mouse_resize((press_arg *)arg)) {
		return;
	}
	
	grab_pointer_cursor(resize_cursors[1]);
	
	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_start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x98d0
cmpl $0x0, %eax
jne 0x9afc
jmp 0x9b2b
leaq 0x6e0d(%rip), %rax      # 0x10910
movl 0x4(%rax), %edi
callq 0x9480
movq -0x8(%rbp), %rdi
callq 0x9b40
callq 0x9b80
leaq 0x69b0(%rip), %rax      # 0x104d0
leaq 0xa9(%rip), %rcx        # 0x9bd0
movq %rcx, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_west
void mouse_resize_west(void *arg) {
	if (!mouse_resize((press_arg *)arg)) {
		return;
	}
	
	grab_pointer_cursor(resize_cursors[7]);
	
	mouse_resize_set_x_west((press_arg *)arg);
	mouse_resize_set_east();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x98d0
cmpl $0x0, %eax
jne 0x9c4c
jmp 0x9c7b
leaq 0x6cbd(%rip), %rax      # 0x10910
movl 0x1c(%rax), %edi
callq 0x9480
movq -0x8(%rbp), %rdi
callq 0x9c90
callq 0x9cd0
leaq 0x6860(%rip), %rax      # 0x104d0
leaq 0xa9(%rip), %rcx        # 0x9d20
movq %rcx, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaiserschmarrn0[P]mywm/mouse.c
// Function: mouse_resize_east
void mouse_resize_east(void *arg) {
	if (!mouse_resize((press_arg *)arg)) {
		return;
	}
	
	grab_pointer_cursor(resize_cursors[3]);
	
	mouse_resize_set_x_east((press_arg *)arg);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x98d0
cmpl $0x0, %eax
jne 0x9d9c
jmp 0x9dc6
leaq 0x6b6d(%rip), %rax      # 0x10910
movl 0xc(%rax), %edi
callq 0x9480
movq -0x8(%rbp), %rdi
callq 0x9950
leaq 0x6715(%rip), %rax      # 0x104d0
leaq 0xe(%rip), %rcx         # 0x9dd0
movq %rcx, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x98d0
cmpl $0x0, %eax
jne 0x9e4c
jmp 0x9e88
leaq 0x6abd(%rip), %rax      # 0x10910
movl (%rax), %edi
callq 0x9480
movq -0x8(%rbp), %rdi
callq 0x9c90
movq -0x8(%rbp), %rdi
callq 0x9b40
callq 0x9cd0
callq 0x9b80
leaq 0x6653(%rip), %rax      # 0x104d0
leaq 0xc(%rip), %rcx         # 0x9e90
movq %rcx, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x98d0
cmpl $0x0, %eax
jne 0x9f0c
jmp 0x9f44
leaq 0x69fd(%rip), %rax      # 0x10910
movl 0x8(%rax), %edi
callq 0x9480
movq -0x8(%rbp), %rdi
callq 0x9950
movq -0x8(%rbp), %rdi
callq 0x9b40
callq 0x9b80
leaq 0x6597(%rip), %rax      # 0x104d0
leaq 0x10(%rip), %rcx        # 0x9f50
movq %rcx, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x98d0
cmpl $0x0, %eax
jne 0x9fcc
jmp 0xa004
leaq 0x693d(%rip), %rax      # 0x10910
movl 0x18(%rax), %edi
callq 0x9480
movq -0x8(%rbp), %rdi
callq 0x9c90
movq -0x8(%rbp), %rdi
callq 0x9990
callq 0x9cd0
leaq 0x64d7(%rip), %rax      # 0x104d0
leaq 0x10(%rip), %rcx        # 0xa010
movq %rcx, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x69ed(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x68a3(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
cmpl $0x7, 0x178(%rax)
je 0xa0a3
jmp 0xa10b
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x0, %al
callq 0x3740
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movswl 0x10(%rax), %eax
subl 0x69c0(%rip), %eax      # 0x10a84
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movswl 0x12(%rax), %eax
subl 0x69b3(%rip), %eax      # 0x10a88
movl %eax, -0x1c(%rbp)
leaq 0x6991(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x6847(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
leaq -0x20(%rbp), %rdx
movl $0x3, %esi
callq 0x63f0
movq -0x18(%rbp), %rdi
callq 0x3270
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0x3740
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x10(%rax), %eax
addl 0x68ff(%rip), %eax      # 0x10a84
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movswl 0x12(%rax), %eax
addl 0x68f2(%rip), %eax      # 0x10a88
movl %eax, -0x14(%rbp)
leaq 0x68d0(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x6786(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
leaq -0x18(%rbp), %rdx
movl $0xc, %esi
callq 0x63f0
movq -0x10(%rbp), %rdi
callq 0x3270
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0x3740
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x12(%rax), %eax
addl 0x6883(%rip), %eax      # 0x10a88
movl %eax, -0x14(%rbp)
leaq 0x6861(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x6717(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
leaq -0x14(%rbp), %rdx
movl $0x8, %esi
callq 0x63f0
movq -0x10(%rbp), %rdi
callq 0x3270
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0x3740
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x12(%rax), %eax
subl 0x6813(%rip), %eax      # 0x10a88
movl %eax, -0x18(%rbp)
movl 0x680e(%rip), %eax      # 0x10a8c
movq -0x10(%rbp), %rcx
movswl 0x12(%rcx), %ecx
subl %ecx, %eax
addl 0x67fa(%rip), %eax      # 0x10a88
movl %eax, -0x14(%rbp)
leaq 0x67d8(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x668e(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
leaq -0x18(%rbp), %rdx
movl $0xa, %esi
callq 0x63f0
movq -0x10(%rbp), %rdi
callq 0x3270
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0x3740
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x10(%rax), %eax
subl 0x678f(%rip), %eax      # 0x10a84
movl %eax, -0x18(%rbp)
movl 0x6792(%rip), %eax      # 0x10a90
movq -0x10(%rbp), %rcx
movswl 0x10(%rcx), %ecx
subl %ecx, %eax
addl 0x6776(%rip), %eax      # 0x10a84
movl %eax, -0x14(%rbp)
leaq 0x6758(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x660e(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
leaq -0x18(%rbp), %rdx
movl $0x5, %esi
callq 0x63f0
movq -0x10(%rbp), %rdi
callq 0x3270
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0x3740
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x10(%rax), %eax
addl 0x670f(%rip), %eax      # 0x10a84
movl %eax, -0x14(%rbp)
leaq 0x66f1(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x65a7(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
leaq -0x14(%rbp), %rdx
movl $0x4, %esi
callq 0x63f0
movq -0x10(%rbp), %rdi
callq 0x3270
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0x3740
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x10(%rax), %eax
subl 0x669f(%rip), %eax      # 0x10a84
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movswl 0x12(%rax), %eax
subl 0x6692(%rip), %eax      # 0x10a88
movl %eax, -0x1c(%rbp)
movl 0x6691(%rip), %eax      # 0x10a90
movq -0x10(%rbp), %rcx
movswl 0x10(%rcx), %ecx
subl %ecx, %eax
addl 0x6675(%rip), %eax      # 0x10a84
movl %eax, -0x18(%rbp)
movl 0x6674(%rip), %eax      # 0x10a8c
movq -0x10(%rbp), %rcx
movswl 0x12(%rcx), %ecx
subl %ecx, %eax
addl 0x6660(%rip), %eax      # 0x10a88
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3270
leaq 0x6635(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x64eb(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
leaq -0x20(%rbp), %rdx
movl $0xf, %esi
callq 0x63f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0x3740
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x12(%rax), %eax
subl 0x65f3(%rip), %eax      # 0x10a88
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movswl 0x10(%rax), %eax
addl 0x65de(%rip), %eax      # 0x10a84
movl %eax, -0x18(%rbp)
movl 0x65dd(%rip), %eax      # 0x10a8c
movq -0x10(%rbp), %rcx
movswl 0x12(%rcx), %ecx
subl %ecx, %eax
addl 0x65c9(%rip), %eax      # 0x10a88
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3270
leaq 0x659e(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x6454(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
leaq -0x1c(%rbp), %rdx
movl $0xe, %esi
callq 0x63f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0x3740
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x10(%rax), %eax
subl 0x655f(%rip), %eax      # 0x10a84
movl %eax, -0x1c(%rbp)
movl 0x6562(%rip), %eax      # 0x10a90
movq -0x10(%rbp), %rcx
movswl 0x10(%rcx), %ecx
subl %ecx, %eax
addl 0x6546(%rip), %eax      # 0x10a84
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movswl 0x12(%rax), %eax
addl 0x6539(%rip), %eax      # 0x10a88
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3270
leaq 0x650e(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x63c4(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
leaq -0x1c(%rbp), %rdx
movl $0xd, %esi
callq 0x63f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x630e(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x61c4(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x48(%rax)
je 0xa7c4
leaq 0x62ef(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x61a5(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
cmpl $0x0, 0x190(%rax)
jne 0xa7c4
leaq 0x62ca(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x6180(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
cmpl $0x0, 0x18c(%rax)
je 0xa7c9
jmp 0xa8ed
movl -0x4(%rbp), %eax
leaq 0x629d(%rip), %rcx      # 0x10a70
movslq (%rcx), %rdx
leaq 0x6153(%rip), %rcx      # 0x10930
imulq $0x50, %rdx, %rdx
addq %rdx, %rcx
movq 0x48(%rcx), %rcx
cmpl 0x178(%rcx), %eax
jne 0xa816
leaq 0x6279(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x612f(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
callq 0xa710
jmp 0xa8ed
leaq 0x6253(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x6109(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
cmpl $0x7, 0x178(%rax)
jne 0xa861
leaq 0x622e(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x60e4(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
movl -0x4(%rbp), %esi
callq 0xa900
jmp 0xa886
movl -0x4(%rbp), %ecx
leaq 0x6205(%rip), %rax      # 0x10a70
movslq (%rax), %rdx
leaq 0x60bb(%rip), %rax      # 0x10930
imulq $0x50, %rdx, %rdx
addq %rdx, %rax
movq 0x48(%rax), %rax
movl %ecx, 0x178(%rax)
leaq 0x61e3(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x6099(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
movslq -0x4(%rbp), %rax
leaq 0x61f3(%rip), %rdx      # 0x10aa0
shlq $0x4, %rax
addq %rax, %rdx
movl $0xf, %esi
callq 0x63f0
leaq 0x5b7f(%rip), %rax      # 0x10444
cmpl $0x1, (%rax)
jne 0xa8cc
jmp 0xa8ed
leaq 0x619d(%rip), %rax      # 0x10a70
movslq (%rax), %rcx
leaq 0x6053(%rip), %rax      # 0x10930
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
callq 0x5d00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbx
subq $0x48, %rsp
movl %edi, -0xc(%rbp)
leaq 0x5805(%rip), %rax      # 0x10448
movq (%rax), %rdi
callq 0x3550
movl %eax, %ecx
movslq -0xc(%rbp), %rdx
leaq 0x5708(%rip), %rax      # 0x10360
imulq $0x1c, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x14(%rax)
movl $0x800, -0x10(%rbp)     # imm = 0x800
movl $0x30, -0x14(%rbp)
leaq 0x57d1(%rip), %rax      # 0x10448
movq (%rax), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x56db(%rip), %rax      # 0x10360
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %edx
leaq 0x57ba(%rip), %rax      # 0x10450
movq (%rax), %rax
movl (%rax), %ecx
leaq 0x57ae(%rip), %rax      # 0x10450
movq (%rax), %rax
movw 0x14(%rax), %bx
leaq 0x57a0(%rip), %rax      # 0x10450
movq (%rax), %rax
movw 0x16(%rax), %r11w
movl -0x10(%rbp), %r10d
xorl %r9d, %r9d
leaq -0x14(%rbp), %rax
movl %r9d, %esi
movl %r9d, %r8d
movzwl %bx, %ebx
movl %ebx, (%rsp)
movzwl %r11w, %r11d
movl %r11d, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
movl %r10d, 0x28(%rsp)
movq %rax, 0x30(%rsp)
callq 0x3030
movl %eax, -0x18(%rbp)
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x55dd(%rip), %rax      # 0x10444
cmpl $0x1, (%rax)
je 0xae6e
jmp 0xaebd
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0x7, %rax
jae 0xaebd
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movslq -0x1c(%rbp), %rdx
leaq 0x54c7(%rip), %rcx      # 0x10360
imulq $0x1c, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x14(%rcx), %eax
jne 0xaeb0
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %edi
callq *%rax
jmp 0xaebd
jmp 0xaeb2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xae7d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0xb090
movl %eax, -0x10(%rbp)
movzbl -0xe(%rbp), %eax
imull $0xffff, %eax, %eax     # imm = 0xFFFF
movl $0xff, %ecx
cltd
idivl %ecx
movw %ax, -0x8(%rbp)
movzbl -0xf(%rbp), %eax
imull $0xffff, %eax, %eax     # imm = 0xFFFF
movl $0xff, %ecx
cltd
idivl %ecx
movw %ax, -0x6(%rbp)
movzbl -0x10(%rbp), %eax
imull $0xffff, %eax, %eax     # imm = 0xFFFF
movl $0xff, %ecx
cltd
idivl %ecx
movw %ax, -0x4(%rbp)
movzbl -0xd(%rbp), %eax
imull $0xffff, %eax, %eax     # imm = 0xFFFF
movl $0xff, %ecx
cltd
idivl %ecx
movw %ax, -0x2(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaiserschmarrn0[P]mywm/color.c
// Function: xcb_color
static uint32_t xcb_color(uint32_t hex) {
	rgba col;
	col.v = hex;

	if (!col.a) {
		return 0U;
	}

	col.r = (col.r * col.a) / 255;
	col.g = (col.g * col.a) / 255;
	col.b = (col.b * col.a) / 255;

	return col.v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpb $0x0, -0x9(%rbp)
jne 0xb0ac
movl $0x0, -0x4(%rbp)
jmp 0xb0f4
movzbl -0xa(%rbp), %eax
movzbl -0x9(%rbp), %ecx
imull %ecx, %eax
movl $0xff, %ecx
cltd
idivl %ecx
movb %al, -0xa(%rbp)
movzbl -0xb(%rbp), %eax
movzbl -0x9(%rbp), %ecx
imull %ecx, %eax
movl $0xff, %ecx
cltd
idivl %ecx
movb %al, -0xb(%rbp)
movzbl -0xc(%rbp), %eax
movzbl -0x9(%rbp), %ecx
imull %ecx, %eax
movl $0xff, %ecx
cltd
idivl %ecx
movb %al, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0xb010
movq %rax, -0x1c(%rbp)
leaq 0x5382(%rip), %rax      # 0x104a0
movq (%rax), %rdi
leaq 0x5388(%rip), %rax      # 0x104b0
movq (%rax), %rsi
leaq 0x538a(%rip), %rax      # 0x104bc
movl (%rax), %eax
movl %eax, %edx
leaq -0x1c(%rbp), %rcx
leaq -0x10(%rbp), %r8
callq 0x3440
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: build_s2l
static void build_s2l(void)
{
	int input;
	double in_f, tmp, val;

	for (input=0; input<=255; input++) {
		in_f = input / 255.0;
		if (in_f <= 0.040448236277) {
			val = in_f / 12.92;
		} else {
			tmp = ((in_f + 0.055)/1.055);
			val = pow(tmp, 2.4);
		}
		s2l_map[input] = val;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0xff, -0x4(%rbp)
jg 0x12e5
cvtsi2sdl -0x4(%rbp), %xmm0
movsd 0x4db7(%rip), %xmm1     # 0x6010
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x4d9e(%rip), %xmm0     # 0x6008
ucomisd -0x10(%rbp), %xmm0
jb 0x1289
movsd -0x10(%rbp), %xmm0
movsd 0x4db2(%rip), %xmm1     # 0x6030
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x12be
movsd 0x4d97(%rip), %xmm0     # 0x6028
addsd -0x10(%rbp), %xmm0
movsd 0x4d82(%rip), %xmm1     # 0x6020
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x4d64(%rip), %xmm1     # 0x6018
callq 0x1060
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movslq -0x4(%rbp), %rcx
leaq 0x7dde(%rip), %rax      # 0x90b0
movss %xmm0, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x123f
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: build_l2s
static void build_l2s(void)
{
	int i, padding;
	double srgb_f, tmp, val;

	padding = L2S_ALL_LEN * 17 / 98;
	l2s_len = L2S_ALL_LEN - 2 * padding;
	l2s_map = l2s_map_all + padding;

	for (i=0; i<l2s_len; i++) {
		srgb_f = (i + 0.5)/(l2s_len - 1);
		if (srgb_f <= 0.00313) {
			val = srgb_f * 12.92;
		} else {
			tmp = pow(srgb_f, 1/2.4);
			val = 1.055 * tmp - 0.055;
		}

		l2s_map[i] = round(val * 255);
	}

	for (i=0; i<padding; i++) {
		l2s_map[l2s_len + i] = 255;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1634, -0x8(%rbp)     # imm = 0x1634
movl -0x8(%rbp), %ecx
shll %ecx
movl $0x8000, %eax           # imm = 0x8000
subl %ecx, %eax
movl %eax, 0x819f(%rip)      # 0x94b0
movslq -0x8(%rbp), %rcx
leaq 0x81a4(%rip), %rax      # 0x94c0
addq %rcx, %rax
movq %rax, 0x1019a(%rip)     # 0x114c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x817a(%rip), %eax      # 0x94b0
jge 0x13f7
cvtsi2sdl -0x4(%rbp), %xmm0
movsd 0x4cf7(%rip), %xmm1     # 0x6040
addsd %xmm1, %xmm0
movl 0x815d(%rip), %eax      # 0x94b0
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x4ccd(%rip), %xmm0     # 0x6038
ucomisd -0x10(%rbp), %xmm0
jb 0x1386
movsd 0x4cb6(%rip), %xmm0     # 0x6030
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x13bf
movsd -0x10(%rbp), %xmm0
movsd 0x4cbd(%rip), %xmm1     # 0x6050
callq 0x1060
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x4c76(%rip), %xmm1     # 0x6020
mulsd %xmm1, %xmm0
movsd 0x4c92(%rip), %xmm1     # 0x6048
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x4c44(%rip), %xmm1     # 0x6010
mulsd %xmm1, %xmm0
callq 0x1040
cvttsd2si %xmm0, %eax
movb %al, %dl
movq 0x100de(%rip), %rax     # 0x114c0
movslq -0x4(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x132d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1428
movq 0x100b3(%rip), %rax     # 0x114c0
movl 0x809d(%rip), %ecx      # 0x94b0
addl -0x4(%rbp), %ecx
movslq %ecx, %rcx
movb $-0x1, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x13fe
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: calc_taps
static int calc_taps(int dim_in, int dim_out)
{
	int tmp;
	if (dim_out > dim_in) {
		return TAPS;
	}
	tmp = TAPS * dim_in / dim_out;
	return tmp - (tmp & 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x178b
movl $0x4, -0x4(%rbp)
jmp 0x17a6
movl -0x8(%rbp), %eax
shll $0x2, %eax
cltd
idivl -0xc(%rbp)
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0x10(%rbp), %ecx
andl $0x1, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1858
jmp 0x1907
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jg 0x194b
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x2260
jmp 0x195e
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x2490
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x19bf
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a0c
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x19ef
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1a0c
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl (%rax), %edx
movl $0x1, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: oil_scale_in
void oil_scale_in(struct oil_scale *os, unsigned char *in)
{
	float *tmp, *coeffs;

	tmp = os->rb;
	if (os->out_height > os->in_height) {
		tmp = get_rb_line(os, os->in_pos % 4);
	}

	if (os->out_width <= os->in_width) {
		oil_xscale_down(in, tmp, os->out_width, os->cs,
			os->coeffs_x, os->borders_x);
		os->borders_y[os->out_pos] -= 1;
	} else {
		oil_xscale_up(in, os->in_width, tmp, os->cs,
			os->coeffs_x, os->borders_x);
	}

	if (os->out_height <= os->in_height) {
		coeffs = os->coeffs_y + os->in_pos * 4;
		yscale_down(tmp, os->out_width, coeffs, os->sums_y, os->cs);
	}

	os->in_pos++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x1a69
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, %esi
callq 0x1b50
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jg 0x1abf
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %r8
movq -0x8(%rbp), %rax
movq 0x30(%rax), %r9
callq 0x1b90
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movl (%rax,%rcx,4), %edx
subl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x1aea
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %r8
movq -0x8(%rbp), %rax
movq 0x30(%rax), %r9
callq 0x1cb0
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x1b3d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r8d
callq 0x1dd0
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: oil_xscale_down
static void oil_xscale_down(unsigned char *in, float *out,
	int width_out, enum oil_colorspace cs_in, float *coeff_buf,
	int *border_buf)
{
	switch(cs_in) {
	case OIL_CS_RGBX:
		xscale_down_rgbx(in, out, width_out, coeff_buf, border_buf);
		break;
	case OIL_CS_RGB:
		xscale_down_rgb(in, out, width_out, coeff_buf, border_buf);
		break;
	case OIL_CS_G:
		xscale_down_g(in, out, width_out, coeff_buf, border_buf);
		break;
	case OIL_CS_CMYK:
		xscale_down_cmyk(in, out, width_out, coeff_buf, border_buf);
		break;
	case OIL_CS_RGBA:
		xscale_down_rgba(in, out, width_out, coeff_buf, border_buf);
		break;
	case OIL_CS_GA:
		xscale_down_ga(in, out, width_out, coeff_buf, border_buf);
		break;
	case OIL_CS_UNKNOWN:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x1ca4
jmp 0x1bbe
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x1c3c
jmp 0x1bc8
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x1c8a
jmp 0x1bd6
movl -0x2c(%rbp), %eax
subl $0x3, %eax
je 0x1c22
jmp 0x1be0
movl -0x2c(%rbp), %eax
subl $0x4, %eax
je 0x1c05
jmp 0x1bea
movl -0x2c(%rbp), %eax
subl $0x104, %eax            # imm = 0x104
je 0x1c70
jmp 0x1bf6
movl -0x2c(%rbp), %eax
subl $0x204, %eax            # imm = 0x204
je 0x1c56
jmp 0x1ca6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x2820
jmp 0x1ca6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x2920
jmp 0x1ca6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x2a20
jmp 0x1ca6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x2af0
jmp 0x1ca6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x2bf0
jmp 0x1ca6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x2d30
jmp 0x1ca6
jmp 0x1ca6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: oil_xscale_up
static void oil_xscale_up(unsigned char *in, int width_in, float *out,
	enum oil_colorspace cs_in, float *coeff_buf, int *border_buf)
{
	switch(cs_in) {
	case OIL_CS_RGBX:
		xscale_up_rgbx(in, width_in, out, coeff_buf, border_buf);
		break;
	case OIL_CS_RGB:
		xscale_up_rgb(in, width_in, out, coeff_buf, border_buf);
		break;
	case OIL_CS_G:
		xscale_up_g(in, width_in, out, coeff_buf, border_buf);
		break;
	case OIL_CS_CMYK:
		xscale_up_cmyk(in, width_in, out, coeff_buf, border_buf);
		break;
	case OIL_CS_RGBA:
		xscale_up_rgba(in, width_in, out, coeff_buf, border_buf);
		break;
	case OIL_CS_GA:
		xscale_up_ga(in, width_in, out, coeff_buf, border_buf);
		break;
	case OIL_CS_UNKNOWN:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x1dc4
jmp 0x1cde
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x1d5c
jmp 0x1ce8
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x1daa
jmp 0x1cf6
movl -0x34(%rbp), %eax
subl $0x3, %eax
je 0x1d42
jmp 0x1d00
movl -0x34(%rbp), %eax
subl $0x4, %eax
je 0x1d25
jmp 0x1d0a
movl -0x34(%rbp), %eax
subl $0x104, %eax            # imm = 0x104
je 0x1d90
jmp 0x1d16
movl -0x34(%rbp), %eax
subl $0x204, %eax            # imm = 0x204
je 0x1d76
jmp 0x1dc6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x2f90
jmp 0x1dc6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x3090
jmp 0x1dc6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x3190
jmp 0x1dc6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x32a0
jmp 0x1dc6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x33a0
jmp 0x1dc6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x34c0
jmp 0x1dc6
jmp 0x1dc6
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: yscale_down
static void yscale_down(float *in, int width, float *coeffs, float *sums,
	enum oil_colorspace cs)
{
	int i, sl_len;

	sl_len = width * OIL_CMP(cs);
	for (i=0; i<sl_len; i++) {
		add_sample_to_sum_f(in[i], coeffs, sums);
		sums += 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl -0x24(%rbp), %ecx
andl $0xff, %ecx
imull %ecx, %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x1e3d
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2e40
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1e04
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: oil_scale_out
void oil_scale_out(struct oil_scale *os, unsigned char *out)
{
	int i, sl_len;
	float *in[4];

	if (os->out_height <= os->in_height) {
		yscale_out(os->sums_y, os->out_width, out, os->cs);
	} else {
		sl_len = OIL_CMP(os->cs) * os->out_width;
		for (i=0; i<4; i++) {
			in[i] = get_rb_line(os, (os->in_pos + i) % 4);
		}
		yscale_up(in, sl_len, os->coeffs_y + os->out_pos * 4, out,
			os->cs);
		os->borders_y[os->in_pos - 1] -= 1;
	}

	os->out_pos++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x1e93
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
callq 0x1f50
jmp 0x1f3c
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
andl $0xff, %eax
movq -0x8(%rbp), %rcx
imull 0xc(%rcx), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x1eeb
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
addl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, %esi
callq 0x1b50
movq %rax, %rcx
movslq -0x14(%rbp), %rax
movq %rcx, -0x40(%rbp,%rax,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1eb1
leaq -0x40(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
shll $0x2, %eax
cltq
shlq $0x2, %rax
addq %rax, %rdx
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r8d
callq 0x2010
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
subl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: yscale_out
static void yscale_out(float *sums, int width, unsigned char *out,
	enum oil_colorspace cs)
{
	int sl_len;

	sl_len = width * OIL_CMP(cs);

	switch(cs) {
	case OIL_CS_G:
	case OIL_CS_CMYK:
		yscale_out_nonlinear(sums, sl_len, out);
		break;
	case OIL_CS_GA:
		yscale_out_ga(sums, width, out);
		break;
	case OIL_CS_RGB:
	case OIL_CS_RGBX:
		yscale_out_linear(sums, sl_len, out);
		break;
	case OIL_CS_RGBA:
		yscale_out_rgba(sums, width, out);
		break;
	case OIL_CS_UNKNOWN:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movzbl -0x1c(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x2004
jmp 0x1f83
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x1fbc
jmp 0x1f8d
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x1fce
jmp 0x1f97
movl -0x24(%rbp), %eax
addl $-0x3, %eax
subl $0x2, %eax
jb 0x1fe0
jmp 0x1fa4
movl -0x24(%rbp), %eax
subl $0x104, %eax            # imm = 0x104
je 0x1ff2
jmp 0x1fb0
movl -0x24(%rbp), %eax
subl $0x204, %eax            # imm = 0x204
jne 0x2006
jmp 0x1fbc
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x3690
jmp 0x2006
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x3700
jmp 0x2006
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x37e0
jmp 0x2006
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x3850
jmp 0x2006
jmp 0x2006
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: yscale_up
static void yscale_up(float **in, int len, float *coeffs, unsigned char *out,
	enum oil_colorspace cs)
{
	switch(cs) {
	case OIL_CS_G:
	case OIL_CS_CMYK:
		yscale_up_g_cmyk(in, len, coeffs, out);
		break;
	case OIL_CS_GA:
		yscale_up_ga(in, len, coeffs, out);
		break;
	case OIL_CS_RGB:
		yscale_up_rgb(in, len, coeffs, out);
		break;
	case OIL_CS_RGBX:
		yscale_up_rgbx(in, len, coeffs, out);
		break;
	case OIL_CS_RGBA:
		yscale_up_rgba(in, len, coeffs, out);
		break;
	case OIL_CS_UNKNOWN:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
testl %eax, %eax
je 0x20e9
jmp 0x203b
movl -0x28(%rbp), %eax
subl $0x1, %eax
je 0x207b
jmp 0x2045
movl -0x28(%rbp), %eax
subl $0x2, %eax
je 0x2091
jmp 0x204f
movl -0x28(%rbp), %eax
subl $0x3, %eax
je 0x20a7
jmp 0x2059
movl -0x28(%rbp), %eax
subl $0x4, %eax
je 0x20bd
jmp 0x2063
movl -0x28(%rbp), %eax
subl $0x104, %eax            # imm = 0x104
je 0x20d3
jmp 0x206f
movl -0x28(%rbp), %eax
subl $0x204, %eax            # imm = 0x204
jne 0x20eb
jmp 0x207b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3a70
jmp 0x20eb
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3b50
jmp 0x20eb
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3cc0
jmp 0x20eb
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3da0
jmp 0x20eb
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3ed0
jmp 0x20eb
jmp 0x20eb
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)