LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_resize_handle
bool parse_resize_handle(char *s, resize_handle_t *h)
{
	if (streq("left", s)) {
		*h = HANDLE_LEFT;
		return true;
	} else if (streq("top", s)) {
		*h = HANDLE_TOP;
		return true;
	} else if (streq("right", s)) {
		*h = HANDLE_RIGHT;
		return true;
	} else if (streq("bottom", s)) {
		*h = HANDLE_BOTTOM;
		return true;
	} else if (streq("top_left", s)) {
		*h = HANDLE_TOP_LEFT;
		return true;
	} else if (streq("top_right", s)) {
		*h = HANDLE_TOP_RIGHT;
		return true;
	} else if (streq("bottom_right", s)) {
		*h = HANDLE_BOTTOM_RIGHT;
		return true;
	} else if (streq("bottom_left", s)) {
		*h = HANDLE_BOTTOM_LEFT;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9f4f(%rip), %rdi      # 0x1fa38
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15b82
leaq 0x8a57(%rip), %rdi      # 0x1e557
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15b86
leaq 0x9f18(%rip), %rdi      # 0x1fa2b
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15b8a
leaq 0x9ee4(%rip), %rdi      # 0x1fa0a
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15b8e
leaq 0x9ed8(%rip), %rdi      # 0x1fa11
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15b92
leaq 0x9ece(%rip), %rdi      # 0x1fa1a
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15b96
leaq 0x9ec5(%rip), %rdi      # 0x1fa24
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15b9a
leaq 0x9ebf(%rip), %rdi      # 0x1fa31
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15b9e
xorl %eax, %eax
jmp 0x15ba5
pushq $0x1
jmp 0x15ba0
pushq $0x2
jmp 0x15ba0
pushq $0x4
jmp 0x15ba0
pushq $0x8
jmp 0x15ba0
pushq $0x3
jmp 0x15ba0
pushq $0x6
jmp 0x15ba0
pushq $0xc
jmp 0x15ba0
pushq $0x9
popq %rax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_modifier_mask
bool parse_modifier_mask(char *s, uint16_t *m)
{
	if (strcmp(s, "shift") == 0) {
		*m = XCB_MOD_MASK_SHIFT;
		return true;
	} else if (strcmp(s, "control") == 0) {
		*m = XCB_MOD_MASK_CONTROL;
		return true;
	} else if (strcmp(s, "lock") == 0) {
		*m = XCB_MOD_MASK_LOCK;
		return true;
	} else if (strcmp(s, "mod1") == 0) {
		*m = XCB_MOD_MASK_1;
		return true;
	} else if (strcmp(s, "mod2") == 0) {
		*m = XCB_MOD_MASK_2;
		return true;
	} else if (strcmp(s, "mod3") == 0) {
		*m = XCB_MOD_MASK_3;
		return true;
	} else if (strcmp(s, "mod4") == 0) {
		*m = XCB_MOD_MASK_4;
		return true;
	} else if (strcmp(s, "mod5") == 0) {
		*m = XCB_MOD_MASK_5;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9e7f(%rip), %rsi      # 0x1fa3d
callq 0x4820
testl %eax, %eax
je 0x15c54
leaq 0x9e71(%rip), %rsi      # 0x1fa43
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x15c5a
leaq 0x9e66(%rip), %rsi      # 0x1fa4b
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x15c60
leaq 0x9e58(%rip), %rsi      # 0x1fa50
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x15c66
leaq 0x9e4a(%rip), %rsi      # 0x1fa55
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x15c6c
leaq 0x9e3c(%rip), %rsi      # 0x1fa5a
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x15c72
leaq 0x9e2e(%rip), %rsi      # 0x1fa5f
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x15c78
leaq 0x9e20(%rip), %rsi      # 0x1fa64
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x15c7e
xorl %eax, %eax
jmp 0x15c87
movw $0x1, %ax
jmp 0x15c82
movw $0x4, %ax
jmp 0x15c82
movw $0x2, %ax
jmp 0x15c82
movw $0x8, %ax
jmp 0x15c82
movw $0x10, %ax
jmp 0x15c82
movw $0x20, %ax
jmp 0x15c82
movw $0x40, %ax
jmp 0x15c82
movw $0x80, %ax
movw %ax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_button_index
bool parse_button_index(char *s, int8_t *b)
{
	if (strcmp(s, "any") == 0) {
		*b = XCB_BUTTON_INDEX_ANY;
		return true;
	} else if (strcmp(s, "button1") == 0) {
		*b = XCB_BUTTON_INDEX_1;
		return true;
	} else if (strcmp(s, "button2") == 0) {
		*b = XCB_BUTTON_INDEX_2;
		return true;
	} else if (strcmp(s, "button3") == 0) {
		*b = XCB_BUTTON_INDEX_3;
		return true;
	} else if (strcmp(s, "none") == 0) {
		*b = -1;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9dc9(%rip), %rsi      # 0x1fa69
callq 0x4820
testl %eax, %eax
je 0x15cf9
leaq 0x9dbd(%rip), %rsi      # 0x1fa6d
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x15cfd
leaq 0x9db2(%rip), %rsi      # 0x1fa75
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x15d01
leaq 0x9da7(%rip), %rsi      # 0x1fa7d
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x15d05
leaq 0x9d9c(%rip), %rsi      # 0x1fa85
movq %r14, %rdi
callq 0x4820
testl %eax, %eax
je 0x15d09
xorl %eax, %eax
jmp 0x15d0f
xorl %eax, %eax
jmp 0x15d0b
movb $0x1, %al
jmp 0x15d0b
movb $0x2, %al
jmp 0x15d0b
movb $0x3, %al
jmp 0x15d0b
movb $-0x1, %al
movb %al, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_pointer_action
bool parse_pointer_action(char *s, pointer_action_t *a)
{
	if (streq("move", s)) {
		*a = ACTION_MOVE;
		return true;
	} else if (streq("resize_corner", s)) {
		*a = ACTION_RESIZE_CORNER;
		return true;
	} else if (streq("resize_side", s)) {
		*a = ACTION_RESIZE_SIDE;
		return true;
	} else if (streq("focus", s)) {
		*a = ACTION_FOCUS;
		return true;
	} else if (streq("none", s)) {
		*a = ACTION_NONE;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x90ff(%rip), %rdi      # 0x1ee27
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15d86
leaq 0x9d4f(%rip), %rdi      # 0x1fa8a
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15d8a
leaq 0x9d4a(%rip), %rdi      # 0x1fa98
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15d8e
leaq 0x8f64(%rip), %rdi      # 0x1ecc5
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15d92
leaq 0x9d11(%rip), %rdi      # 0x1fa85
movq %r14, %rsi
callq 0x4820
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x15d99
jmp 0x15d95
pushq $0x2
jmp 0x15d94
pushq $0x4
jmp 0x15d94
pushq $0x3
jmp 0x15d94
pushq $0x1
popq %rax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_child_polarity
bool parse_child_polarity(char *s, child_polarity_t *p)
{
	if (streq("first_child", s)) {
		*p = FIRST_CHILD;
		return true;
	} else if (streq("second_child", s)) {
		*p = SECOND_CHILD;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9b9e(%rip), %rdi      # 0x1f950
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15dd5
leaq 0x9b97(%rip), %rdi      # 0x1f95c
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15dd9
xorl %eax, %eax
jmp 0x15de0
xorl %eax, %eax
jmp 0x15ddc
pushq $0x1
popq %rax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_automatic_scheme
bool parse_automatic_scheme(char *s, automatic_scheme_t *a)
{
	if (streq("longest_side", s)) {
		*a = SCHEME_LONGEST_SIDE;
		return true;
	} else if (streq("alternate", s)) {
		*a = SCHEME_ALTERNATE;
		return true;
	} else if (streq("spiral", s)) {
		*a = SCHEME_SPIRAL;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9b70(%rip), %rdi      # 0x1f969
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15e2f
leaq 0x9b6a(%rip), %rdi      # 0x1f976
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15e33
leaq 0x9b61(%rip), %rdi      # 0x1f980
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15e37
xorl %eax, %eax
jmp 0x15e3e
xorl %eax, %eax
jmp 0x15e3a
pushq $0x1
jmp 0x15e39
pushq $0x2
popq %rax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_honor_size_hints_mode
bool parse_honor_size_hints_mode(char *s, honor_size_hints_mode_t *a)
{
	bool b;
	if (parse_bool(s, &b)) {
		*a = b ? HONOR_SIZE_HINTS_YES : HONOR_SIZE_HINTS_NO;
		return true;
	} else if (streq("floating", s)) {
		*a = HONOR_SIZE_HINTS_FLOATING;
		return true;
	} else if (streq("tiled", s)) {
		*a = HONOR_SIZE_HINTS_TILED;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7(%rsp), %rsi
callq 0x15728
testb %al, %al
je 0x15e65
movzbl 0x7(%rsp), %eax
jmp 0x15e96
leaq 0x9e3a(%rip), %rdi      # 0x1fca6
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15e8f
leaq 0x9dd6(%rip), %rdi      # 0x1fc55
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15e93
xorl %eax, %eax
jmp 0x15e9a
pushq $0x2
jmp 0x15e95
pushq $0x3
popq %rax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_state_transition
bool parse_state_transition(char *s, state_transition_t *m)
{
	if (streq("none", s)) {
		*m = 0;
		return true;
	} else if (streq("all", s)) {
		*m = STATE_TRANSITION_ENTER | STATE_TRANSITION_EXIT;
		return true;
	} else {
		state_transition_t w = 0;
		char *x = copy_string(s, strlen(s));
		char *key = strtok(x, ",");
		while (key != NULL) {
			if (streq("enter", key)) {
				w |= STATE_TRANSITION_ENTER;
			} else if (streq("exit", key)) {
				w |= STATE_TRANSITION_EXIT;
			} else {
				free(x);
				return false;
			}
			key = strtok(NULL, ",");
		}
		free(x);
		if (w != 0) {
			*m = w;
			return true;
		} else {
			return false;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9bc8(%rip), %rdi      # 0x1fa85
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15f5a
leaq 0x9bd0(%rip), %rdi      # 0x1faa4
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x15f78
movq %rbx, 0x10(%rsp)
movq %r14, %rdi
callq 0x4470
movq %r14, %rdi
movq %rax, %rsi
callq 0x5d82
xorl %r14d, %r14d
leaq 0xa0e4(%rip), %r15      # 0x1ffea
leaq 0xa675(%rip), %r12      # 0x20582
pushq $0x1
popq %rbx
pushq $0x2
popq %r13
movq %rax, 0x8(%rsp)
movq %rax, %rdi
movq %r15, %rsi
callq 0x4850
testq %rax, %rax
je 0x15f5f
movq %rax, %rbp
movq %r12, %rdi
movq %rax, %rsi
callq 0x4820
movl %ebx, %ecx
testl %eax, %eax
je 0x15f53
leaq 0xa209(%rip), %rdi      # 0x2014d
movq %rbp, %rsi
callq 0x4820
movl %r13d, %ecx
testl %eax, %eax
jne 0x15f82
orl %ecx, %r14d
xorl %edi, %edi
jmp 0x15f1c
andl $0x0, (%rbx)
jmp 0x15f7e
movq 0x8(%rsp), %rdi
callq 0x4460
testl %r14d, %r14d
je 0x15f8c
movq 0x10(%rsp), %rax
movl %r14d, (%rax)
jmp 0x15f7e
movl $0x3, (%rbx)
movb $0x1, %al
jmp 0x15f8e
movq 0x8(%rsp), %rdi
callq 0x4460
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_degree
bool parse_degree(char *s, int *d)
{
	int i = atoi(s);
	while (i < 0)
		i += 360;
	while (i > 359)
		i -= 360;
	if ((i % 90) != 0) {
		return false;
	} else {
		*d = i;
		return true;
	}
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x46b0
movl %eax, %ecx
testl %eax, %eax
movl $0x0, %eax
cmovgl %ecx, %eax
movl %ecx, %esi
shrl $0x1f, %esi
subl %ecx, %eax
subl %esi, %eax
movl $0x168, %edi            # imm = 0x168
xorl %edx, %edx
divl %edi
addl %esi, %eax
imull $0x168, %eax, %r8d      # imm = 0x168
addl %ecx, %r8d
cmpl %edi, %r8d
movl $0x167, %esi            # imm = 0x167
cmovael %r8d, %esi
movl %esi, %eax
xorl %edx, %edx
divl %edi
movl %edx, %ecx
subl %esi, %ecx
addl %r8d, %ecx
movw $0x5a, %si
movl %ecx, %eax
xorl %edx, %edx
divw %si
testw %dx, %dx
jne 0x16040
movl %ecx, (%rbx)
testw %dx, %dx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_id
bool parse_id(char *s, uint32_t *id)
{
	char *end;
	errno = 0;
	uint32_t v = strtol(s, &end, 0);
	if (errno != 0 || *end != '\0') {
		return false;
	}
	*id = v;
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x47a0
movq %rax, %r15
andl $0x0, (%rax)
movq %rsp, %rsi
xorl %ebp, %ebp
movq %r14, %rdi
xorl %edx, %edx
callq 0x4680
cmpl $0x0, (%r15)
jne 0x16087
movq (%rsp), %rcx
cmpb $0x0, (%rcx)
je 0x16082
xorl %ebp, %ebp
jmp 0x16087
movl %eax, (%rbx)
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_bool_declaration
bool parse_bool_declaration(char *s, char **key, bool *value, alter_state_t *state)
{
	*key = strtok(s, EQL_TOK);
	char *v = strtok(NULL, EQL_TOK);
	if (v == NULL) {
		*state = ALTER_TOGGLE;
		return true;
	} else {
		if (parse_bool(v, value)) {
			*state = ALTER_SET;
			return true;
		} else {
			return false;
		}
	}
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x8ce7(%rip), %r12      # 0x1ed93
movq %r12, %rsi
callq 0x4850
movq %rax, (%r15)
xorl %r15d, %r15d
xorl %edi, %edi
movq %r12, %rsi
callq 0x4850
testq %rax, %rax
je 0x160dc
movq %rax, %rdi
movq %r14, %rsi
callq 0x15728
testb %al, %al
je 0x160e3
pushq $0x1
popq %r15
movl %r15d, (%rbx)
movb $0x1, %al
jmp 0x160e5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_rectangle
bool parse_rectangle(char *s, xcb_rectangle_t *r)
{
	uint16_t w, h;
	int16_t x, y;
	if (sscanf(s, "%hux%hu+%hi+%hi", &w, &h, &x, &y) != 4) {
		return false;
	}
	r->width = w;
	r->height = h;
	r->x = x;
	r->y = y;
	return true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x9993(%rip), %rsi      # 0x1faad
leaq 0xe(%rsp), %rdx
leaq 0xc(%rsp), %rcx
leaq 0xa(%rsp), %r8
leaq 0x8(%rsp), %r9
xorl %eax, %eax
callq 0x41c0
cmpl $0x4, %eax
jne 0x1615d
movzwl 0xe(%rsp), %ecx
movw %cx, 0x4(%rbx)
movzwl 0xc(%rsp), %ecx
movw %cx, 0x6(%rbx)
movzwl 0xa(%rsp), %ecx
movw %cx, (%rbx)
movzwl 0x8(%rsp), %ecx
movw %cx, 0x2(%rbx)
cmpl $0x4, %eax
sete %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/parse.c
// Function: parse_monitor_modifiers
bool parse_monitor_modifiers(char *desc, monitor_select_t *sel)
{
	char *tok;
	while ((tok = strrchr(desc, CAT_CHR)) != NULL) {
		tok[0] = '\0';
		tok++;
		if (streq("occupied", tok)) {
			sel->occupied = OPTION_TRUE;
		} else if (streq("!occupied", tok)) {
			sel->occupied = OPTION_FALSE;
		GET_MOD(focused)
		} else {
			return false;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x2e
popq %rbp
leaq 0x96bc(%rip), %r15      # 0x1fc2b
movq %r14, %rdi
movl %ebp, %esi
callq 0x4560
movq %rax, %r13
testq %rax, %rax
je 0x165f7
movb $0x0, (%r13)
leaq 0x1(%r13), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4820
testl %eax, %eax
je 0x165db
leaq 0x968a(%rip), %rdi      # 0x1fc2a
movq %r12, %rsi
callq 0x4820
testl %eax, %eax
je 0x165e3
leaq 0x9682(%rip), %rdi      # 0x1fc35
movq %r12, %rsi
callq 0x4820
testl %eax, %eax
je 0x165eb
leaq 0x966e(%rip), %rdi      # 0x1fc34
movq %r12, %rsi
callq 0x4820
testl %eax, %eax
jne 0x165f7
movl $0x2, 0x4(%rbx)
jmp 0x1656f
movl $0x1, (%rbx)
jmp 0x1656f
movl $0x2, (%rbx)
jmp 0x1656f
movl $0x1, 0x4(%rbx)
jmp 0x1656f
testq %r13, %r13
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: query_state
void query_state(FILE *rsp)
{
	fprintf(rsp, "{");
	fprintf(rsp, "\"focusedMonitorId\":%u,", mon->id);
	if (pri_mon != NULL) {
		fprintf(rsp, "\"primaryMonitorId\":%u,", pri_mon->id);
	}
	fprintf(rsp, "\"clientsCount\":%i,", clients_count);
	fprintf(rsp, "\"monitors\":");
	fprintf(rsp, "[");
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		query_monitor(m, rsp);
		if (m->next != NULL) {
			fprintf(rsp, ",");
		}
	}
	fprintf(rsp, "]");
	fprintf(rsp,",");
	fprintf(rsp, "\"focusHistory\":");
	query_history(rsp);
	fprintf(rsp,",");
	fprintf(rsp, "\"stackingList\":");
	query_stack(rsp);
	if (restart) {
		fprintf(rsp,",");
		fprintf(rsp, "\"eventSubscribers\":");
		query_subscribers(rsp);
	}
	fprintf(rsp, "}");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x7b
popq %rdi
movq %rbx, %rsi
callq 0x4420
leaq 0x11750(%rip), %rax     # 0x28710
movq (%rax), %rax
movl 0x20(%rax), %edx
leaq 0x8dbf(%rip), %rsi      # 0x1fd8c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a30
leaq 0x1171a(%rip), %rax     # 0x286f8
movq (%rax), %rax
testq %rax, %rax
je 0x16ffa
movl 0x20(%rax), %edx
leaq 0x8db3(%rip), %rsi      # 0x1fda3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a30
leaq 0x116f3(%rip), %rax     # 0x286f4
movl (%rax), %edx
leaq 0x8db0(%rip), %rsi      # 0x1fdba
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a30
leaq 0x8db2(%rip), %rdi      # 0x1fdcd
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x49e0
leaq 0x116d8(%rip), %r15     # 0x28708
pushq $0x5b
popq %rdi
pushq $0x2c
popq %rbp
movq %rbx, %rsi
callq 0x4420
movq (%r15), %r14
testq %r14, %r14
je 0x17060
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1710d
leaq 0x78(%r14), %r15
cmpq $0x0, 0x78(%r14)
je 0x1703e
movl %ebp, %edi
jmp 0x17036
pushq $0x5d
popq %rdi
movq %rbx, %rsi
callq 0x4420
pushq $0x2c
popq %rbp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x4420
leaq 0x8d5a(%rip), %rdi      # 0x1fdd9
pushq $0xf
popq %r14
pushq $0x1
popq %r15
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x49e0
movq %rbx, %rdi
callq 0x172ae
movl %ebp, %edi
movq %rbx, %rsi
callq 0x4420
leaq 0x8d3b(%rip), %rdi      # 0x1fde9
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x49e0
movq %rbx, %rdi
callq 0x17304
leaq 0x11615(%rip), %rax     # 0x286e0
cmpb $0x0, (%rax)
je 0x170f8
pushq $0x2c
popq %rdi
movq %rbx, %rsi
callq 0x4420
leaq 0x8d17(%rip), %rdi      # 0x1fdf9
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x49e0
movq %rbx, %rdi
callq 0x1736a
pushq $0x7d
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4420
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: query_monitor
void query_monitor(monitor_t *m, FILE *rsp)
{
	fprintf(rsp, "{");
	fprintf(rsp, "\"name\":\"%s\",", m->name);
	fprintf(rsp, "\"id\":%u,", m->id);
	fprintf(rsp, "\"randrId\":%u,", m->randr_id);
	fprintf(rsp, "\"wired\":%s,", BOOL_STR(m->wired));
	fprintf(rsp, "\"stickyCount\":%i,", m->sticky_count);
	fprintf(rsp, "\"windowGap\":%i,", m->window_gap);
	fprintf(rsp, "\"borderWidth\":%u,", m->border_width);
	fprintf(rsp, "\"focusedDesktopId\":%u,", m->desk->id);
	fprintf(rsp, "\"padding\":");
	query_padding(m->padding, rsp);
	fprintf(rsp,",");
	fprintf(rsp, "\"rectangle\":");
	query_rectangle(m->rectangle, rsp);
	fprintf(rsp,",");
	fprintf(rsp, "\"desktops\":");
	fprintf(rsp, "[");
	for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
		query_desktop(d, rsp);
		if (d->next != NULL) {
			fprintf(rsp,",");
		}
	}
	fprintf(rsp, "]");
	fprintf(rsp, "}");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x7b
popq %rdi
callq 0x4420
leaq 0x8ce4(%rip), %rsi      # 0x1fe0d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4a30
movl 0x20(%r14), %edx
leaq 0x8cd9(%rip), %rsi      # 0x1fe1a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a30
movl 0x24(%r14), %edx
leaq 0x8ccd(%rip), %rsi      # 0x1fe23
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a30
leaq 0x8820(%rip), %rax      # 0x1f987
leaq 0x881e(%rip), %rdx      # 0x1f98c
cmpb $0x0, 0x2c(%r14)
cmovneq %rax, %rdx
leaq 0x8cb3(%rip), %rsi      # 0x1fe31
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a30
movl 0x40(%r14), %edx
leaq 0x8caa(%rip), %rsi      # 0x1fe3d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a30
movl 0x44(%r14), %edx
leaq 0x8ca7(%rip), %rsi      # 0x1fe4f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a30
movl 0x48(%r14), %edx
leaq 0x8ca2(%rip), %rsi      # 0x1fe5f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a30
movq 0x58(%r14), %rax
movl 0x20(%rax), %edx
leaq 0x8c9c(%rip), %rsi      # 0x1fe71
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a30
leaq 0x8ca2(%rip), %rdi      # 0x1fe88
pushq $0xa
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
movq %rbx, %rcx
callq 0x49e0
movq 0x30(%r14), %rdi
movq 0x38(%r14), %rsi
movq %rbx, %rdx
callq 0x17414
pushq $0x2c
popq %rbp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x4420
leaq 0x8c77(%rip), %rdi      # 0x1fe93
pushq $0xc
popq %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x49e0
movq 0x4c(%r14), %rdi
movq %rbx, %rsi
callq 0x1743e
movl %ebp, %edi
movq %rbx, %rsi
callq 0x4420
leaq 0x8c59(%rip), %rdi      # 0x1fea0
pushq $0xb
popq %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x49e0
pushq $0x5b
popq %rdi
movq %rbx, %rsi
callq 0x4420
addq $0x60, %r14
movq (%r14), %r15
testq %r15, %r15
je 0x1728e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1746d
leaq 0x48(%r15), %r14
cmpq $0x0, 0x48(%r15)
je 0x17264
movl %ebp, %edi
movq %rbx, %rsi
callq 0x4420
jmp 0x17264
pushq $0x5d
popq %rdi
movq %rbx, %rsi
callq 0x4420
pushq $0x7d
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4420
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: query_history
void query_history(FILE *rsp)
{
	fprintf(rsp, "[");
	for (history_t *h = history_head; h != NULL; h = h->next) {
		query_coordinates(&h->loc, rsp);
		if (h->next != NULL) {
			fprintf(rsp, ",");
		}
	}
	fprintf(rsp, "]");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x11469(%rip), %r15     # 0x28728
pushq $0x5b
popq %rdi
pushq $0x2c
popq %rbp
movq %rbx, %rsi
callq 0x4420
movq (%r15), %r14
testq %r14, %r14
je 0x172ef
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17ac5
leaq 0x28(%r14), %r15
cmpq $0x0, 0x28(%r14)
je 0x172cd
movl %ebp, %edi
jmp 0x172c5
pushq $0x5d
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4420
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: query_stack
void query_stack(FILE *rsp)
{
	fprintf(rsp, "[");
	for (stacking_list_t *s = stack_head; s != NULL; s = s->next) {
		fprintf(rsp, "%u", s->node->id);
		if (s->next != NULL) {
			fprintf(rsp, ",");
		}
	}
	fprintf(rsp, "]");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x11432(%rip), %r15     # 0x28748
pushq $0x5b
popq %rdi
leaq 0x82af(%rip), %r14      # 0x1f5cf
pushq $0x2c
popq %rbp
movq %rbx, %rsi
callq 0x4420
movq (%r15), %r12
testq %r12, %r12
je 0x17357
movq (%r12), %rax
movl (%rax), %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4a30
leaq 0x10(%r12), %r15
cmpq $0x0, 0x10(%r12)
je 0x1732b
movl %ebp, %edi
jmp 0x17323
pushq $0x5d
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4420
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: query_subscribers
void query_subscribers(FILE *rsp)
{
	fprintf(rsp, "[");
	for (subscriber_list_t *s = subscribe_head; s != NULL; s = s->next) {
		fprintf(rsp, "{\"fileDescriptor\": %i", fileno(s->stream));
		if (s->fifo_path != NULL) {
			fprintf(rsp, ",\"fifoPath\":\"%s\"", s->fifo_path);
		}
		fprintf(rsp, ",\"field\":%i,\"count\":%i}", s->field, s->count);
		if (s->next != NULL) {
			fprintf(rsp, ",");
		}
	}
	fprintf(rsp, "]");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x113d9(%rip), %rbp     # 0x28758
pushq $0x5b
popq %rdi
leaq 0x8d83(%rip), %r14      # 0x2010c
leaq 0x8da3(%rip), %r15      # 0x20133
leaq 0x8d8b(%rip), %r12      # 0x20122
movq %rbx, %rsi
callq 0x4420
movq (%rbp), %r13
testq %r13, %r13
je 0x173fb
movq (%r13), %rdi
callq 0x4060
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x4a30
movq 0x8(%r13), %rdx
testq %rdx, %rdx
je 0x173d6
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4a30
movl 0x10(%r13), %edx
movl 0x14(%r13), %ecx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4a30
leaq 0x20(%r13), %rbp
cmpq $0x0, 0x20(%r13)
je 0x1739f
pushq $0x2c
popq %rdi
jmp 0x17397
pushq $0x5d
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4420
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: query_desktop
void query_desktop(desktop_t *d, FILE *rsp)
{
	fprintf(rsp, "{");
	fprintf(rsp, "\"name\":\"%s\",", d->name);
	fprintf(rsp, "\"id\":%u,", d->id);
	fprintf(rsp, "\"layout\":\"%s\",", LAYOUT_STR(d->layout));
	fprintf(rsp, "\"userLayout\":\"%s\",", LAYOUT_STR(d->user_layout));
	fprintf(rsp, "\"windowGap\":%i,", d->window_gap);
	fprintf(rsp, "\"borderWidth\":%u,", d->border_width);
	fprintf(rsp, "\"focusedNodeId\":%u,", d->focus != NULL ? d->focus->id : 0);
	fprintf(rsp, "\"padding\":");
	query_padding(d->padding, rsp);
	fprintf(rsp,",");
	fprintf(rsp, "\"root\":");
	query_node(d->root, rsp);
	fprintf(rsp, "}");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x7b
popq %rdi
callq 0x4420
leaq 0x8983(%rip), %rsi      # 0x1fe0d
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4a30
movl 0x20(%r14), %edx
leaq 0x8976(%rip), %rsi      # 0x1fe1a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a30
cmpl $0x0, 0x24(%r14)
leaq 0x879b(%rip), %r12      # 0x1fc55
leaq 0x879b(%rip), %r15      # 0x1fc5c
movq %r15, %rdx
cmoveq %r12, %rdx
leaq 0x89dd(%rip), %rsi      # 0x1feac
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a30
cmpl $0x0, 0x28(%r14)
cmoveq %r12, %r15
leaq 0x89d2(%rip), %rsi      # 0x1febb
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x4a30
movl 0x60(%r14), %edx
leaq 0x894e(%rip), %rsi      # 0x1fe4f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a30
movl 0x64(%r14), %edx
leaq 0x8949(%rip), %rsi      # 0x1fe5f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4a30
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x1752b
movl (%rax), %ebp
leaq 0x899c(%rip), %rsi      # 0x1fece
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x4a30
leaq 0x8943(%rip), %rdi      # 0x1fe88
pushq $0xa
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
movq %rbx, %rcx
callq 0x49e0
movq 0x50(%r14), %rdi
movq 0x58(%r14), %rsi
movq %rbx, %rdx
callq 0x17414
pushq $0x2c
popq %rdi
movq %rbx, %rsi
callq 0x4420
leaq 0x8969(%rip), %rdi      # 0x1fee2
pushq $0x7
popq %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x49e0
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x175a6
pushq $0x7d
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4420
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: query_presel
void query_presel(presel_t *p, FILE *rsp)
{
	if (p == NULL) {
		fprintf(rsp, "null");
	} else {
		fprintf(rsp, "{\"splitDir\":\"%s\",\"splitRatio\":%lf}", SPLIT_DIR_STR(p->split_dir), p->split_ratio);
	}
}

// Assembly:
movq %rsi, %rcx
testq %rdi, %rdi
je 0x1783a
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x1784c
cmpl $0x1, %eax
jne 0x17855
leaq 0x8a09(%rip), %rdx      # 0x20241
jmp 0x1786a
leaq 0x86a9(%rip), %rdi      # 0x1feea
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
jmp 0x49e0
leaq 0x6e16(%rip), %rdx      # 0x1e669
jmp 0x1786a
cmpl $0x2, %eax
leaq 0x6e10(%rip), %rax      # 0x1e66f
leaq 0x6e0f(%rip), %rdx      # 0x1e675
cmoveq %rax, %rdx
movsd (%rdi), %xmm0
leaq 0x872d(%rip), %rsi      # 0x1ffa2
movq %rcx, %rdi
movb $0x1, %al
jmp 0x4a30
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: query_node_ids
int query_node_ids(coordinates_t *mon_ref, coordinates_t *desk_ref, coordinates_t* ref, coordinates_t *trg, monitor_select_t *mon_sel, desktop_select_t *desk_sel, node_select_t *sel, FILE *rsp)
{
	int count = 0;
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		coordinates_t loc = {m, NULL, NULL};
		if ((trg->monitor != NULL && m != trg->monitor) ||
		    (mon_sel != NULL && !monitor_matches(&loc, mon_ref, mon_sel))) {
			continue;
		}
		for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
			coordinates_t loc = {m, d, NULL};
			if ((trg->desktop != NULL && d != trg->desktop) ||
			    (desk_sel != NULL && !desktop_matches(&loc, desk_ref, desk_sel))) {
				continue;
			}
			count += query_node_ids_in(d->root, d, m, ref, trg, sel, rsp);
		}
	}
	return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbx
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
leaq 0x10beb(%rip), %rbp     # 0x28708
xorl %r14d, %r14d
movq %r8, 0x8(%rsp)
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x17bf5
movq %rbp, 0x30(%rsp)
leaq 0x38(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq (%r15), %rax
testq %rax, %rax
setne %cl
cmpq %rax, %rbp
setne %al
testb %al, %cl
jne 0x17bec
testq %r13, %r13
je 0x17b6f
leaq 0x30(%rsp), %rdi
movq %r13, %rdx
callq 0x17c07
testb %al, %al
je 0x17bec
leaq 0x60(%rbp), %r13
movq (%r13), %r13
testq %r13, %r13
je 0x17be7
movq %rbp, 0x18(%rsp)
movq %r13, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x17b9a
cmpq %rax, %r13
jne 0x17be1
testq %rbx, %rbx
je 0x17bb5
leaq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x17c4d
testb %al, %al
je 0x17be1
movq 0x30(%r13), %rdi
movq 0x88(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rsi
movq %rbp, %rdx
movq %r12, %rcx
movq %r15, %r8
movq 0x80(%rsp), %r9
callq 0x17d9f
addl %eax, %r14d
addq $0x48, %r13
jmp 0x17b73
movq 0x8(%rsp), %r13
addq $0x78, %rbp
jmp 0x17b25
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: monitor_matches
bool monitor_matches(coordinates_t *loc, __attribute__((unused)) coordinates_t *ref, monitor_select_t *sel)
{
	if (sel->occupied != OPTION_NONE &&
	    loc->monitor->desk->root == NULL
	    ? sel->occupied == OPTION_TRUE
	    : sel->occupied == OPTION_FALSE) {
		return false;
	}

	if (sel->focused != OPTION_NONE &&
	    loc->monitor != mon
	    ? sel->focused == OPTION_TRUE
	    : sel->focused == OPTION_FALSE) {
		return false;
	}

	return true;
}

// Assembly:
movl (%rdx), %eax
testl %eax, %eax
je 0x17c27
movq (%rdi), %rcx
movq 0x58(%rcx), %rcx
cmpq $0x0, 0x30(%rcx)
je 0x17c22
cmpl $0x2, %eax
jne 0x17c27
jmp 0x17c42
cmpl $0x1, %eax
je 0x17c42
movl 0x4(%rdx), %eax
testl %eax, %eax
je 0x17c4a
movq (%rdi), %rcx
leaq 0x10ad8(%rip), %rdx     # 0x28710
cmpq (%rdx), %rcx
je 0x17c45
cmpl $0x1, %eax
jne 0x17c4a
xorl %eax, %eax
retq
cmpl $0x2, %eax
je 0x17c42
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: query_node_ids_in
int query_node_ids_in(node_t *n, desktop_t *d, monitor_t *m, coordinates_t *ref, coordinates_t *trg, node_select_t *sel, FILE *rsp)
{
	int count = 0;
	if (n == NULL) {
		return 0;
	} else {
		coordinates_t loc = {m, d, n};
		if ((trg->node == NULL || n == trg->node) &&
		    (sel == NULL || node_matches(&loc, ref, sel))) {
			fprintf(rsp, "0x%08X\n", n->id);
			count++;
		}
		count += query_node_ids_in(n->first_child, d, m, ref, trg, sel, rsp);
		count += query_node_ids_in(n->second_child, d, m, ref, trg, sel, rsp);
	}
	return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r14
movq %rcx, 0x18(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
xorl %ebx, %ebx
testq %rbp, %rbp
je 0x17e65
movq %r12, 0x20(%rsp)
movq %r13, 0x28(%rsp)
movq %rbp, 0x30(%rsp)
movq 0x10(%r14), %rax
testq %rax, %rax
setne %cl
cmpq %rbp, %rax
setne %al
xorl %r15d, %r15d
testb %al, %cl
jne 0x17e2e
cmpq $0x0, 0x10(%rsp)
je 0x17e14
leaq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x17e76
testb %al, %al
je 0x17e2e
movl (%rbp), %edx
movq 0x70(%rsp), %rdi
leaq 0x6999(%rip), %rsi      # 0x1e7bc
xorl %eax, %eax
callq 0x4a30
pushq $0x1
popq %r15
movq 0x30(%rbp), %rdi
movq 0x70(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rsi
movq %r12, %rdx
movq 0x18(%rsp), %rcx
movq %r14, %r8
movq 0x10(%rsp), %r9
callq 0x17d9f
movq 0x38(%rbp), %rbp
addl %ebx, %r15d
addl %eax, %r15d
movl %r15d, %ebx
jmp 0x17dc5
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: query_desktop_ids
int query_desktop_ids(coordinates_t* mon_ref, coordinates_t *ref, coordinates_t *trg, monitor_select_t *mon_sel, desktop_select_t *sel, desktop_printer_t printer, FILE *rsp)
{
	int count = 0;
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		coordinates_t loc = {m, NULL, NULL};
		if ((trg->monitor != NULL && m != trg->monitor) ||
		    (mon_sel != NULL && !monitor_matches(&loc, mon_ref, mon_sel))) {
			continue;
		}
		for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
			coordinates_t loc = {m, d, NULL};
			if ((trg->desktop != NULL && d != trg->desktop) ||
			    (sel != NULL && !desktop_matches(&loc, ref, sel))) {
				continue;
			}
			printer(d, rsp);
			count++;
		}
	}
	return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
leaq 0x1043f(%rip), %r13     # 0x28708
xorl %r15d, %r15d
movq %rcx, 0x8(%rsp)
movq (%r13), %r13
testq %r13, %r13
je 0x18383
movq %r13, 0x30(%rsp)
leaq 0x38(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq (%r12), %rax
testq %rax, %rax
setne %cl
cmpq %rax, %r13
setne %al
testb %al, %cl
jne 0x1837a
testq %rbp, %rbp
je 0x18318
leaq 0x30(%rsp), %rdi
movq %rbp, %rdx
callq 0x17c07
testb %al, %al
je 0x1837a
leaq 0x60(%r13), %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x18375
movq %r13, 0x18(%rsp)
movq %rbp, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x18344
cmpq %rax, %rbp
jne 0x1836f
testq %r14, %r14
je 0x1835f
leaq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x17c4d
testb %al, %al
je 0x1836f
movq %rbp, %rdi
movq 0x80(%rsp), %rsi
callq *%rbx
incl %r15d
addq $0x48, %rbp
jmp 0x1831c
movq 0x8(%rsp), %rbp
addq $0x78, %r13
jmp 0x182d1
movl %r15d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: query_monitor_ids
int query_monitor_ids(coordinates_t *ref, coordinates_t *trg, monitor_select_t *sel, monitor_printer_t printer, FILE *rsp)
{
	int count = 0;
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		coordinates_t loc = {m, NULL, NULL};
		if ((trg->monitor != NULL && m != trg->monitor) ||
		    (sel != NULL && !monitor_matches(&loc, ref, sel))) {
			continue;
		}
		printer(m, rsp);
		count++;
	}
	return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x10350(%rip), %r13     # 0x28708
xorl %ebp, %ebp
leaq 0x18(%rsp), %rbx
xorps %xmm0, %xmm0
movq (%r13), %r13
testq %r13, %r13
je 0x18413
movq %r13, 0x10(%rsp)
movups %xmm0, (%rbx)
movq (%r12), %rax
testq %rax, %rax
setne %cl
cmpq %rax, %r13
setne %al
testb %al, %cl
jne 0x1840d
testq %r15, %r15
je 0x183fd
leaq 0x10(%rsp), %rdi
movq %r15, %rdx
callq 0x17c07
testb %al, %al
je 0x1840a
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq *%r14
incl %ebp
xorps %xmm0, %xmm0
addq $0x78, %r13
jmp 0x183c2
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: print_ignore_request
void print_ignore_request(state_transition_t st, FILE *rsp)
{
	if (st == 0) {
		fprintf(rsp, "none");
	} else {
		unsigned int cnt = 0;
		if (st & STATE_TRANSITION_ENTER) {
			fprintf(rsp, "enter");
			cnt++;
		}
		if (st & STATE_TRANSITION_EXIT) {
			fprintf(rsp, "%sexit", cnt > 0 ? "," : "");
		}
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
testl %edi, %edi
je 0x184b4
movl %edi, %ebp
testb $0x1, %bpl
je 0x184a7
leaq 0x80e9(%rip), %rdi      # 0x20582
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x49e0
testb $0x2, %bpl
jne 0x184cf
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x75ca(%rip), %rdi      # 0x1fa85
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x49e0
testb $0x1, %bpl
leaq 0x807e(%rip), %rax      # 0x20558
leaq 0x7b09(%rip), %rdx      # 0x1ffea
cmoveq %rax, %rdx
leaq 0x7c5f(%rip), %rsi      # 0x2014b
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4a30
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: print_modifier_mask
void print_modifier_mask(uint16_t m, FILE *rsp)
{
	switch (m) {
		case XCB_MOD_MASK_SHIFT:
			fprintf(rsp, "shift");
			break;
		case XCB_MOD_MASK_CONTROL:
			fprintf(rsp, "control");
			break;
		case XCB_MOD_MASK_LOCK:
			fprintf(rsp, "lock");
			break;
		case XCB_MOD_MASK_1:
			fprintf(rsp, "mod1");
			break;
		case XCB_MOD_MASK_2:
			fprintf(rsp, "mod2");
			break;
		case XCB_MOD_MASK_3:
			fprintf(rsp, "mod3");
			break;
		case XCB_MOD_MASK_4:
			fprintf(rsp, "mod4");
			break;
		case XCB_MOD_MASK_5:
			fprintf(rsp, "mod5");
			break;
	}
}

// Assembly:
movq %rsi, %rcx
leal -0x1(%rdi), %eax
cmpl $0x7, %eax
jbe 0x18527
cmpl $0x10, %edi
je 0x18560
cmpl $0x20, %edi
je 0x18572
cmpl $0x40, %edi
je 0x18569
cmpl $0x80, %edi
jne 0x18542
leaq 0x753f(%rip), %rdi      # 0x1fa64
jmp 0x18579
leaq 0x780a(%rip), %rdx      # 0x1fd38
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
leaq 0x74ff(%rip), %rdi      # 0x1fa3d
pushq $0x5
jmp 0x1857b
retq
leaq 0x7506(%rip), %rdi      # 0x1fa50
jmp 0x18579
leaq 0x74f0(%rip), %rdi      # 0x1fa43
pushq $0x7
jmp 0x1857b
leaq 0x74ed(%rip), %rdi      # 0x1fa4b
jmp 0x18579
leaq 0x74ee(%rip), %rdi      # 0x1fa55
jmp 0x18579
leaq 0x74ef(%rip), %rdi      # 0x1fa5f
jmp 0x18579
leaq 0x74e1(%rip), %rdi      # 0x1fa5a
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
jmp 0x49e0
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: print_button_index
void print_button_index(int8_t b, FILE *rsp)
{
	switch (b) {
		case XCB_BUTTON_INDEX_ANY:
			fprintf(rsp, "any");
			break;
		case XCB_BUTTON_INDEX_1:
			fprintf(rsp, "button1");
			break;
		case XCB_BUTTON_INDEX_2:
			fprintf(rsp, "button2");
			break;
		case XCB_BUTTON_INDEX_3:
			fprintf(rsp, "button3");
			break;
		case -1:
			fprintf(rsp, "none");
			break;
	}
}

// Assembly:
incl %edi
cmpl $0x4, %edi
ja 0x185d8
movq %rsi, %rcx
leaq 0x77c3(%rip), %rax      # 0x1fd58
movslq (%rax,%rdi,4), %rdx
addq %rax, %rdx
jmpq *%rdx
leaq 0x74e0(%rip), %rdi      # 0x1fa85
pushq $0x4
jmp 0x185cf
leaq 0x74cd(%rip), %rdi      # 0x1fa7d
jmp 0x185c2
leaq 0x74b4(%rip), %rdi      # 0x1fa6d
jmp 0x185c2
leaq 0x74b3(%rip), %rdi      # 0x1fa75
pushq $0x7
jmp 0x185cf
leaq 0x749c(%rip), %rdi      # 0x1fa69
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
jmp 0x49e0
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: print_pointer_action
void print_pointer_action(pointer_action_t a, FILE *rsp)
{
	switch (a) {
		case ACTION_MOVE:
			fprintf(rsp, "move");
			break;
		case ACTION_RESIZE_SIDE:
			fprintf(rsp, "resize_side");
			break;
		case ACTION_RESIZE_CORNER:
			fprintf(rsp, "resize_corner");
			break;
		case ACTION_FOCUS:
			fprintf(rsp, "focus");
			break;
		case ACTION_NONE:
			fprintf(rsp, "none");
			break;
	}
}

// Assembly:
cmpl $0x4, %edi
ja 0x1862f
movq %rsi, %rcx
movl %edi, %eax
leaq 0x7782(%rip), %rdx      # 0x1fd6c
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
leaq 0x748b(%rip), %rdi      # 0x1fa85
jmp 0x1860e
leaq 0x7487(%rip), %rdi      # 0x1fa8a
pushq $0xd
jmp 0x18626
leaq 0x6819(%rip), %rdi      # 0x1ee27
pushq $0x4
jmp 0x18626
leaq 0x747f(%rip), %rdi      # 0x1fa98
pushq $0xb
jmp 0x18626
leaq 0x66a1(%rip), %rdi      # 0x1ecc5
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
jmp 0x49e0
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: resolve_rule_consequence
void resolve_rule_consequence(rule_consequence_t *csq)
{
	coordinates_t ref = {mon, mon->desk, mon->desk->focus};
	coordinates_t dst = {NULL, NULL, NULL};
	monitor_t *monitor = monitor_from_desc(csq->monitor_desc, &ref, &dst) != SELECTOR_OK ? NULL : dst.monitor;
	desktop_t *desktop = desktop_from_desc(csq->desktop_desc, &ref, &dst) != SELECTOR_OK ? NULL : dst.desktop;
	node_t *node = node_from_desc(csq->node_desc, &ref, &dst) != SELECTOR_OK ? NULL : dst.node;

#define PRINT_OBJECT_ID(name) \
	if (name == NULL) { \
		csq->name##_desc[0] = '\0'; \
	} else { \
		snprintf(csq->name##_desc, 11, "0x%08X", name->id); \
	}
	PRINT_OBJECT_ID(monitor)
	PRINT_OBJECT_ID(desktop)
	PRINT_OBJECT_ID(node)
#undef PRINT_OBJECT_ID
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x100c8(%rip), %rax     # 0x28710
movq (%rax), %rax
leaq 0x30(%rsp), %r12
movq %rax, (%r12)
movq 0x58(%rax), %rax
movq %rax, 0x8(%r12)
movq 0x38(%rax), %rax
movq %rax, 0x10(%r12)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r13
movaps %xmm0, (%r13)
andq $0x0, 0x10(%r13)
addq $0x300, %rdi            # imm = 0x300
movq %rdi, (%rsp)
movq %r12, %rsi
movq %r13, %rdx
callq 0x1876b
testl %eax, %eax
setne %r15b
movq (%r13), %r14
leaq 0x400(%rbx), %rdi
movq %rdi, 0x8(%rsp)
movq %r12, %rsi
movq %r13, %rdx
callq 0x18a95
movl $0x0, %ebp
testl %eax, %eax
jne 0x186bd
movq 0x18(%rsp), %rbp
addq $0x500, %rbx            # imm = 0x500
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x18ebb
testl %eax, %eax
movl $0x0, %r12d
jne 0x186e1
movq 0x20(%rsp), %r12
testq %r14, %r14
sete %al
orb %al, %r15b
cmpb $0x1, %r15b
jne 0x186f9
movq (%rsp), %rax
movb $0x0, (%rax)
jmp 0x18712
movl 0x20(%r14), %ecx
leaq 0x7a4e(%rip), %rdx      # 0x20152
pushq $0xb
popq %rsi
movq (%rsp), %rdi
xorl %eax, %eax
callq 0x4110
testq %rbp, %rbp
je 0x18732
movl 0x20(%rbp), %ecx
leaq 0x7a31(%rip), %rdx      # 0x20152
pushq $0xb
popq %rsi
movq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x4110
jmp 0x1873a
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
testq %r12, %r12
je 0x18759
movl (%r12), %ecx
leaq 0x7a08(%rip), %rdx      # 0x20152
pushq $0xb
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4110
jmp 0x1875c
movb $0x0, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: locate_leaf
bool locate_leaf(xcb_window_t win, coordinates_t *loc)
{
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
			for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root)) {
				if (n->id == win) {
					loc->monitor = m;
					loc->desktop = d;
					loc->node = n;
					return true;
				}
			}
		}
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xefd5(%rip), %r14      # 0x28708
movq (%r14), %r14
testq %r14, %r14
je 0x1977e
leaq 0x60(%r14), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x1976d
movq 0x30(%r15), %rdi
callq 0x8e72
testq %rax, %rax
je 0x19767
cmpl %ebp, (%rax)
je 0x19773
movq 0x30(%r15), %rsi
movq %rax, %rdi
callq 0x8ed0
jmp 0x19750
addq $0x48, %r15
jmp 0x1973f
addq $0x78, %r14
jmp 0x19733
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
movq %rax, 0x10(%rbx)
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: locate_desktop
bool locate_desktop(char *name, coordinates_t *loc)
{
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
			if (streq(d->name, name)) {
				loc->monitor = m;
				loc->desktop = d;
				return true;
			}
		}
	}
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xef64(%rip), %r12      # 0x28708
movq (%r12), %r12
testq %r12, %r12
je 0x197dc
leaq 0x60(%r12), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x197cf
movq %r15, %rdi
movq %r14, %rsi
callq 0x4820
testl %eax, %eax
je 0x197d5
addq $0x48, %r15
jmp 0x197b2
addq $0x78, %r12
jmp 0x197a4
movq %r12, (%rbx)
movq %r15, 0x8(%rbx)
testq %r12, %r12
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: desktop_from_index
bool desktop_from_index(uint16_t idx, coordinates_t *loc, monitor_t *mm)
{
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		if (mm != NULL && m != mm) {
			continue;
		}
		for (desktop_t *d = m->desk_head; d != NULL; d = d->next, idx--) {
			if (idx == 1) {
				loc->monitor = m;
				loc->desktop = d;
				loc->node = NULL;
				return true;
			}
		}
	}
	return false;
}

// Assembly:
leaq 0xef13(%rip), %rax      # 0x28708
movq (%rax), %rax
testq %rax, %rax
je 0x1983b
testq %rdx, %rdx
setne %cl
cmpq %rdx, %rax
setne %r8b
testb %r8b, %cl
jne 0x19829
leaq 0x60(%rax), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x19829
cmpw $0x1, %di
je 0x1982f
addq $0x48, %rcx
decl %edi
jmp 0x19813
addq $0x78, %rax
jmp 0x197f5
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
andq $0x0, 0x10(%rsi)
testq %rax, %rax
setne %al
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: desktop_from_id
bool desktop_from_id(uint32_t id, coordinates_t *loc, monitor_t *mm)
{
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		if (mm != NULL && m != mm) {
			continue;
		}
		for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
			if (d->id == id) {
				loc->monitor = m;
				loc->desktop = d;
				loc->node = NULL;
				return true;
			}
		}
	}
	return false;
}

// Assembly:
leaq 0xeebf(%rip), %rax      # 0x28708
movq (%rax), %rax
testq %rax, %rax
je 0x1988c
testq %rdx, %rdx
setne %cl
cmpq %rdx, %rax
setne %r8b
testb %r8b, %cl
jne 0x1987a
leaq 0x60(%rax), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x1987a
cmpl %edi, 0x20(%rcx)
je 0x19880
addq $0x48, %rcx
jmp 0x19867
addq $0x78, %rax
jmp 0x19849
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
andq $0x0, 0x10(%rsi)
testq %rax, %rax
setne %al
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/query.c
// Function: desktop_from_name
bool desktop_from_name(char *name, coordinates_t *ref, coordinates_t *dst, desktop_select_t *sel, int *hits)
{
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
			if (streq(d->name, name)) {
				if (hits != NULL) {
					(*hits)++;
				}
				coordinates_t loc = {m, d, NULL};
				if (desktop_matches(&loc, ref, sel)) {
					dst->monitor = m;
					dst->desktop = d;
					return true;
				}
			}
		}
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %r13
leaq 0xee4f(%rip), %rbp      # 0x28708
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x19921
leaq 0x60(%rbp), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1990f
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4820
testl %eax, %eax
jne 0x19909
testq %r14, %r14
je 0x198e5
incl (%r14)
movq %rbp, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x17c4d
testb %al, %al
jne 0x19915
addq $0x48, %rbx
jmp 0x198c6
addq $0x78, %rbp
jmp 0x198b9
movq 0x8(%rsp), %rax
movq %rbp, (%rax)
movq %rbx, 0x8(%rax)
testq %rbp, %rbp
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq