LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: get_rectangle
xcb_rectangle_t get_rectangle(monitor_t *m, desktop_t *d, node_t *n)
{
	if (n == NULL) {
		return m->rectangle;
	}
	client_t *c = n->client;
	if (c != NULL) {
		if (IS_FLOATING(c)) {
			return c->floating_rectangle;
		} else {
			return c->tiled_rectangle;
		}
	} else {
		int wg = (d == NULL ? 0 : (gapless_monocle && d->layout == LAYOUT_MONOCLE ? 0 : d->window_gap));
		xcb_rectangle_t rect = n->rectangle;
		rect.width -= wg;
		rect.height -= wg;
		return rect;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc818
movq -0x10(%rbp), %rax
movq 0x4c(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc8c1
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc85a
movq -0x28(%rbp), %rax
cmpl $0x2, 0x308(%rax)
jne 0xc849
movq -0x28(%rbp), %rax
movq 0x318(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc8c1
movq -0x28(%rbp), %rax
movq 0x320(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc8c1
cmpq $0x0, -0x18(%rbp)
jne 0xc868
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0xc895
leaq 0x29578(%rip), %rax     # 0x35de7
testb $0x1, (%rax)
je 0xc885
movq -0x18(%rbp), %rax
cmpl $0x1, 0x24(%rax)
jne 0xc885
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0xc88f
movq -0x18(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movl -0x2c(%rbp), %ecx
movzwl -0x4(%rbp), %eax
subl %ecx, %eax
movw %ax, -0x4(%rbp)
movl -0x2c(%rbp), %ecx
movzwl -0x2(%rbp), %eax
subl %ecx, %eax
movw %ax, -0x2(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: tiled_count
int tiled_count(node_t *n, bool include_receptacles)
{
	if (n == NULL) {
		return 0;
	}
	int cnt = 0;
	for (node_t *f = first_extrema(n); f != NULL; f = next_leaf(f, n)) {
		if (!f->hidden && ((include_receptacles && f->client == NULL) ||
		                   (f->client != NULL && IS_TILED(f->client)))) {
			cnt++;
		}
	}
	return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc8f7
movl $0x0, -0x4(%rbp)
jmp 0xc97e
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbe70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc978
movq -0x20(%rbp), %rax
testb $0x1, 0x25(%rax)
jne 0xc963
testb $0x1, -0x11(%rbp)
je 0xc92d
movq -0x20(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xc95a
movq -0x20(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xc963
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
cmpl $0x0, 0x308(%rax)
je 0xc95a
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
cmpl $0x1, 0x308(%rax)
jne 0xc963
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc965
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xbf80
movq %rax, -0x20(%rbp)
jmp 0xc90b
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: set_marked
void set_marked(monitor_t *m, desktop_t *d, node_t *n, bool value)
{
	if (n == NULL || n->marked == value) {
		return;
	}

	n->marked = value;

	put_status(SBSC_MASK_NODE_FLAG, "node_flag 0x%08X 0x%08X 0x%08X marked %s\n", m->id, d->id, n->id, ON_OFF_STR(value));

	if (n == m->desk->focus) {
		put_status(SBSC_MASK_REPORT);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xca0b
movq -0x18(%rbp), %rax
movb 0x29(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x19(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0xca0d
jmp 0xca7a
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x29(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x18(%rbp), %rax
movl (%rax), %r8d
movb -0x19(%rbp), %sil
leaq 0x2100c(%rip), %r9      # 0x2da46
leaq 0x22266(%rip), %rax     # 0x2eca7
testb $0x1, %sil
cmovneq %rax, %r9
movl $0x2000000, %edi        # imm = 0x2000000
leaq 0x21074(%rip), %rsi     # 0x2dac9
movb $0x0, %al
callq 0x2c0b0
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
cmpq 0x38(%rcx), %rax
jne 0xca7a
movl $0x1, %edi
movb $0x0, %al
callq 0x2c0b0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: propagate_flags_upward
void propagate_flags_upward(monitor_t *m, desktop_t *d, node_t *n)
{
	if (n == NULL) {
		return;
	}

	node_t *p = n->parent;

	if (p != NULL) {
		set_vacant_local(m, d, p, (p->first_child->vacant && p->second_child->vacant));
		set_hidden_local(m, d, p, (p->first_child->hidden && p->second_child->hidden));
		update_constraints(p);
	}

	propagate_flags_upward(m, d, p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xcaa0
jmp 0xcb77
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xcb66
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
xorl %eax, %eax
testb $0x1, 0x24(%rcx)
movb %al, -0x21(%rbp)
je 0xcaf0
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movb 0x24(%rax), %al
movb %al, -0x21(%rbp)
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
movb -0x21(%rbp), %al
movzbl %al, %ecx
andl $0x1, %ecx
callq 0x10c00
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
xorl %eax, %eax
testb $0x1, 0x25(%rcx)
movb %al, -0x41(%rbp)
je 0xcb43
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movb 0x25(%rax), %al
movb %al, -0x41(%rbp)
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
movb -0x41(%rbp), %al
movzbl %al, %ecx
andl $0x1, %ecx
callq 0x11350
movq -0x20(%rbp), %rdi
callq 0xb960
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xca80
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: is_focusable
bool is_focusable(node_t *n)
{
	for (node_t *f = first_extrema(n); f != NULL; f = next_leaf(f, n)) {
		if (f->client != NULL && !f->hidden) {
			return true;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbe70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xcbd0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xcbbb
movq -0x18(%rbp), %rax
testb $0x1, 0x25(%rax)
jne 0xcbbb
movb $0x1, -0x1(%rbp)
jmp 0xcbd4
jmp 0xcbbd
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xbf80
movq %rax, -0x18(%rbp)
jmp 0xcb99
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: insert_receptacle
void insert_receptacle(monitor_t *m, desktop_t *d, node_t *n)
{
	node_t *r = make_node(XCB_NONE);
	insert_node(m, d, r, n);
	put_status(SBSC_MASK_NODE_ADD, "node_add 0x%08X 0x%08X 0x%08X 0x%08X\n", m->id, d->id, n != NULL ? n->id : 0, r->id);

	if (single_monocle && d->layout == LAYOUT_MONOCLE && tiled_count(d->root, true) > 1) {
		set_layout(m, d, d->user_layout, false);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %edi, %edi
callq 0xc700
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0xc020
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xcc3a
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0xcc41
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0xcc41
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %edx
movl -0x2c(%rbp), %r8d
movq -0x20(%rbp), %rax
movl (%rax), %r9d
movl $0x8000, %edi           # imm = 0x8000
leaq 0x20c19(%rip), %rsi     # 0x2d877
movb $0x0, %al
callq 0x2c0b0
leaq 0x2917c(%rip), %rax     # 0x35de8
testb $0x1, (%rax)
je 0xcca8
movq -0x10(%rbp), %rax
cmpl $0x1, 0x24(%rax)
jne 0xcca8
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl $0x1, %esi
callq 0xc8d0
cmpl $0x1, %eax
jle 0xcca8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %edx
xorl %ecx, %ecx
callq 0x9e80
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: first_focusable_leaf
node_t *first_focusable_leaf(node_t *n)
{
	for (node_t *f = first_extrema(n); f != NULL; f = next_leaf(f, n)) {
		if (f->client != NULL && !f->hidden) {
			return f;
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbe70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xcf14
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xceff
movq -0x18(%rbp), %rax
testb $0x1, 0x25(%rax)
jne 0xceff
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcf1c
jmp 0xcf01
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xbf80
movq %rax, -0x18(%rbp)
jmp 0xced9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: neutralize_occluding_windows
void neutralize_occluding_windows(monitor_t *m, desktop_t *d, node_t *n)
{
	bool changed = false;
	for (node_t *f = first_extrema(n); f != NULL; f = next_leaf(f, n)) {
		for (node_t *a = first_extrema(d->root); a != NULL; a = next_leaf(a, d->root)) {
			if (a != f && a->client != NULL && f->client != NULL &&
			    IS_FULLSCREEN(a->client) && stack_cmp(f->client, a->client) < 0) {
				set_state(m, d, a, a->client->last_state);
				changed = true;
			}
		}
	}
	if (changed) {
		arrange(m, d);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbe70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xd01e
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xbe70
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xd006
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xcfea
movq -0x30(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xcfea
movq -0x28(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xcfea
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
cmpl $0x3, 0x308(%rax)
jne 0xcfea
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x11f60
cmpl $0x0, %eax
jge 0xcfea
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
movl 0x30c(%rax), %ecx
callq 0x10e30
movb $0x1, -0x19(%rbp)
jmp 0xcfec
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xbf80
movq %rax, -0x30(%rbp)
jmp 0xcf71
jmp 0xd008
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xbf80
movq %rax, -0x28(%rbp)
jmp 0xcf55
testb $0x1, -0x19(%rbp)
je 0xd031
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xafd0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: is_descendant
bool is_descendant(node_t *a, node_t *b)
{
	if (a == NULL || b == NULL) {
		return false;
	}
	while (a != b && a != NULL) {
		a = a->parent;
	}
	return a == b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd05a
cmpq $0x0, -0x18(%rbp)
jne 0xd060
movb $0x0, -0x1(%rbp)
jmp 0xd0a3
jmp 0xd062
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x19(%rbp)
je 0xd07c
cmpq $0x0, -0x10(%rbp)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xd085
jmp 0xd093
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xd062
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: transfer_sticky_nodes
void transfer_sticky_nodes(monitor_t *ms, desktop_t *ds, monitor_t *md, desktop_t *dd, node_t *n)
{
	if (n == NULL) {
		return;
	} else if (n->sticky) {
		sticky_still = false;
		transfer_node(ms, ds, n, md, dd, dd->focus, false);
		sticky_still = true;
	} else {
		/* we need references to the children because n might be freed after
		 * the first recursive call */
		node_t *first_child = n->first_child;
		node_t *second_child = n->second_child;
		transfer_sticky_nodes(ms, ds, md, dd, first_child);
		transfer_sticky_nodes(ms, ds, md, dd, second_child);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xd0d8
jmp 0xd16e
movq -0x28(%rbp), %rax
testb $0x1, 0x26(%rax)
je 0xd122
leaq 0x28671(%rip), %rax     # 0x3575a
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x20(%rbp), %rax
movq 0x38(%rax), %r9
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0xd180
leaq 0x2863d(%rip), %rax     # 0x3575a
movb $0x1, (%rax)
jmp 0xd16c
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xd0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0xd0b0
jmp 0xd16e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: set_urgent
void set_urgent(monitor_t *m, desktop_t *d, node_t *n, bool value)
{
	if (value && mon->desk->focus == n) {
		return;
	}

	n->client->urgent = value;

	if (value) {
		n->client->wm_flags |= WM_FLAG_DEMANDS_ATTENTION;
	} else {
		n->client->wm_flags &= ~WM_FLAG_DEMANDS_ATTENTION;
	}

	ewmh_wm_state_update(n);

	put_status(SBSC_MASK_NODE_FLAG, "node_flag 0x%08X 0x%08X 0x%08X urgent %s\n", m->id, d->id, n->id, ON_OFF_STR(value));
	put_status(SBSC_MASK_REPORT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0xdcce
leaq 0x27a48(%rip), %rax     # 0x35700
movq (%rax), %rax
movq 0x58(%rax), %rax
movq 0x38(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xdcce
jmp 0xdd75
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
andb $0x1, %cl
movb %cl, 0x304(%rax)
testb $0x1, -0x19(%rbp)
je 0xdd04
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movl 0x378(%rax), %ecx
orl $0x800, %ecx            # imm = 0x800
movl %ecx, 0x378(%rax)
jmp 0xdd1e
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movl 0x378(%rax), %ecx
andl $0xfffff7ff, %ecx       # imm = 0xFFFFF7FF
movl %ecx, 0x378(%rax)
movq -0x18(%rbp), %rdi
callq 0x2b810
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x18(%rbp), %rax
movl (%rax), %r8d
movb -0x19(%rbp), %sil
leaq 0x1fcff(%rip), %r9      # 0x2da46
leaq 0x20f59(%rip), %rax     # 0x2eca7
testb $0x1, %sil
cmovneq %rax, %r9
movl $0x2000000, %edi        # imm = 0x2000000
leaq 0x1fd91(%rip), %rsi     # 0x2daf3
movb $0x0, %al
callq 0x2c0b0
movl $0x1, %edi
movb $0x0, %al
callq 0x2c0b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: hide_node
void hide_node(desktop_t *d, node_t *n)
{
	if (n == NULL || (!hide_sticky && n->sticky)) {
		return;
	} else {
		if (!n->hidden) {
			if (n->presel != NULL && d->layout != LAYOUT_MONOCLE) {
				window_hide(n->presel->feedback);
			}
			if (n->client != NULL) {
				window_hide(n->id);
			}
		}
		if (n->client != NULL) {
			n->client->shown = false;
		}
		hide_node(d, n->first_child);
		hide_node(d, n->second_child);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xddad
leaq 0x279bb(%rip), %rax     # 0x35759
testb $0x1, (%rax)
jne 0xddb2
movq -0x10(%rbp), %rax
testb $0x1, 0x26(%rax)
je 0xddb2
jmp 0xde35
movq -0x10(%rbp), %rax
testb $0x1, 0x25(%rax)
jne 0xddf9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xdde1
movq -0x8(%rbp), %rax
cmpl $0x1, 0x24(%rax)
je 0xdde1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rax), %edi
callq 0x16f50
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xddf7
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x16f50
jmp 0xddf9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xde13
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movb $0x0, 0x305(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xdd80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0xdd80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: show_node
void show_node(desktop_t *d, node_t *n)
{
	if (n == NULL) {
		return;
	} else {
		if (!n->hidden) {
			if (n->client != NULL) {
				window_show(n->id);
			}
			if (n->presel != NULL && d->layout != LAYOUT_MONOCLE) {
				window_show(n->presel->feedback);
			}
		}
		if (n->client != NULL) {
			n->client->shown = true;
		}
		show_node(d, n->first_child);
		show_node(d, n->second_child);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xde5c
jmp 0xdedf
movq -0x10(%rbp), %rax
testb $0x1, 0x25(%rax)
jne 0xdea3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xde7c
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x16590
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xdea1
movq -0x8(%rbp), %rax
cmpl $0x1, 0x24(%rax)
je 0xdea1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rax), %edi
callq 0x16590
jmp 0xdea3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xdebd
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movb $0x1, 0x305(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xde40
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0xde40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: make_client
client_t *make_client(void)
{
	client_t *c = calloc(1, sizeof(client_t));
	c->state = c->last_state = STATE_TILED;
	c->layer = c->last_layer = LAYER_NORMAL;
	snprintf(c->class_name, sizeof(c->class_name), "%s", MISSING_VALUE);
	snprintf(c->instance_name, sizeof(c->instance_name), "%s", MISSING_VALUE);
	c->border_width = border_width;
	c->urgent = false;
	c->shown = false;
	c->wm_flags = 0;
	c->icccm_props.input_hint = true;
	c->icccm_props.take_focus = false;
	c->icccm_props.delete_window = false;
	c->size_hints.flags = 0;
	c->honor_size_hints = honor_size_hints;
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x37c, %esi            # imm = 0x37C
callq 0x4890
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x30c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x308(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x314(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x310(%rax)
movq -0x8(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
leaq 0x1f19d(%rip), %rdx     # 0x2d0f0
leaq 0x1f9bb(%rip), %rcx     # 0x2d915
movb $0x0, %al
callq 0x4120
movq -0x8(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl $0x100, %esi            # imm = 0x100
leaq 0x1f178(%rip), %rdx     # 0x2d0f0
leaq 0x1f996(%rip), %rcx     # 0x2d915
movb $0x0, %al
callq 0x4120
leaq 0x27e27(%rip), %rax     # 0x35db4
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x300(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x304(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x305(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x378(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x375(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x374(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x376(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x32c(%rax)
leaq 0x27e05(%rip), %rax     # 0x35df8
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x328(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: clients_count_in
unsigned int clients_count_in(node_t *n)
{
	if (n == NULL) {
		return 0;
	} else {
		return (n->client != NULL ? 1 : 0) +
		        clients_count_in(n->first_child) +
		        clients_count_in(n->second_child);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe52c
movl $0x0, -0x4(%rbp)
jmp 0xe573
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xe510
movl %eax, %ecx
movl -0x18(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xe510
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: brother_tree
node_t *brother_tree(node_t *n)
{
	if (n == NULL || n->parent == NULL) {
		return NULL;
	}
	if (is_first_child(n)) {
		return n->parent->second_child;
	} else {
		return n->parent->first_child;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe59e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0xe5a8
movq $0x0, -0x8(%rbp)
jmp 0xe5d9
movq -0x10(%rbp), %rdi
callq 0xc6b0
testb $0x1, %al
jne 0xe5b7
jmp 0xe5c9
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xe5d9
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: second_extrema
node_t *second_extrema(node_t *n)
{
	if (n == NULL) {
		return NULL;
	} else if (n->second_child == NULL) {
		return n;
	} else {
		return second_extrema(n->second_child);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe60d
movq $0x0, -0x8(%rbp)
jmp 0xe633
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xe622
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe633
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xe5f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: next_node
node_t *next_node(node_t *n)
{
	if (n == NULL) {
		return NULL;
	}

	if (n->second_child != NULL) {
		return first_extrema(n->second_child);
	} else {
		node_t *p = n;
		while (is_second_child(p)) {
			p = p->parent;
		}
		if (is_first_child(p)) {
			return p->parent;
		} else {
			return NULL;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe65d
movq $0x0, -0x8(%rbp)
jmp 0xe6c5
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xe67b
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xbe70
movq %rax, -0x8(%rbp)
jmp 0xe6c5
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe4c0
testb $0x1, %al
jne 0xe692
jmp 0xe6a0
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xe683
movq -0x18(%rbp), %rdi
callq 0xc6b0
testb $0x1, %al
jne 0xe6af
jmp 0xe6bd
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xe6c5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: prev_node
node_t *prev_node(node_t *n)
{
	if (n == NULL) {
		return NULL;
	}

	if (n->first_child != NULL) {
		return second_extrema(n->first_child);
	} else {
		node_t *p = n;
		while (is_first_child(p)) {
			p = p->parent;
		}
		if (is_second_child(p)) {
			return p->parent;
		} else {
			return NULL;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe6ed
movq $0x0, -0x8(%rbp)
jmp 0xe755
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xe70b
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xe5f0
movq %rax, -0x8(%rbp)
jmp 0xe755
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc6b0
testb $0x1, %al
jne 0xe722
jmp 0xe730
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xe713
movq -0x18(%rbp), %rdi
callq 0xe4c0
testb $0x1, %al
jne 0xe73f
jmp 0xe74d
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xe755
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: prev_leaf
node_t *prev_leaf(node_t *n, node_t *r)
{
	if (n == NULL) {
		return NULL;
	}
	node_t *p = n;
	while (is_first_child(p) && p != r) {
		p = p->parent;
	}
	if (p == r) {
		return NULL;
	}
	return second_extrema(p->parent->first_child);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe781
movq $0x0, -0x8(%rbp)
jmp 0xe7ee
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xc6b0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0xe7a0
jmp 0xe7ae
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xe7b7
jmp 0xe7c5
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xe789
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xe7d9
movq $0x0, -0x8(%rbp)
jmp 0xe7ee
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x30(%rax), %rdi
callq 0xe5f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: next_tiled_leaf
node_t *next_tiled_leaf(node_t *n, node_t *r)
{
	node_t *next = next_leaf(n, r);
	if (next == NULL || (next->client != NULL && !next->vacant)) {
		return next;
	} else {
		return next_tiled_leaf(next, r);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xbf80
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe83d
movq -0x20(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xe847
movq -0x20(%rbp), %rax
testb $0x1, 0x24(%rax)
jne 0xe847
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe858
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe800
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: prev_tiled_leaf
node_t *prev_tiled_leaf(node_t *n, node_t *r)
{
	node_t *prev = prev_leaf(n, r);
	if (prev == NULL || (prev->client != NULL && !prev->vacant)) {
		return prev;
	} else {
		return prev_tiled_leaf(prev, r);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe760
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe8ad
movq -0x20(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xe8b7
movq -0x20(%rbp), %rax
testb $0x1, 0x24(%rax)
jne 0xe8b7
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe8c8
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe870
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: is_adjacent
bool is_adjacent(node_t *a, node_t *b, direction_t dir)
{
	switch (dir) {
		case DIR_EAST:
			return (a->rectangle.x + a->rectangle.width) == b->rectangle.x;
			break;
		case DIR_SOUTH:
			return (a->rectangle.y + a->rectangle.height) == b->rectangle.y;
			break;
		case DIR_WEST:
			return (b->rectangle.x + b->rectangle.width) == a->rectangle.x;
			break;
		case DIR_NORTH:
			return (b->rectangle.y + b->rectangle.height) == a->rectangle.y;
			break;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x3, %rax
ja 0xe9ac
movq -0x28(%rbp), %rax
leaq 0x1ee95(%rip), %rcx     # 0x2d7a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movswl 0x18(%rax), %eax
movq -0x10(%rbp), %rcx
movzwl 0x1c(%rcx), %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movswl 0x18(%rcx), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe9b0
movq -0x10(%rbp), %rax
movswl 0x1a(%rax), %eax
movq -0x10(%rbp), %rcx
movzwl 0x1e(%rcx), %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movswl 0x1a(%rcx), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe9b0
movq -0x18(%rbp), %rax
movswl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1c(%rcx), %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movswl 0x18(%rcx), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe9b0
movq -0x18(%rbp), %rax
movswl 0x1a(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1e(%rcx), %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movswl 0x1a(%rcx), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe9b0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: find_fence
node_t *find_fence(node_t *n, direction_t dir)
{
	node_t *p;

	if (n == NULL) {
		return NULL;
	}

	p = n->parent;

	while (p != NULL) {
		if ((dir == DIR_NORTH && p->split_type == TYPE_HORIZONTAL && p->rectangle.y < n->rectangle.y) ||
		    (dir == DIR_WEST && p->split_type == TYPE_VERTICAL && p->rectangle.x < n->rectangle.x) ||
		    (dir == DIR_SOUTH && p->split_type == TYPE_HORIZONTAL && (p->rectangle.y + p->rectangle.height) > (n->rectangle.y + n->rectangle.height)) ||
		    (dir == DIR_EAST && p->split_type == TYPE_VERTICAL && (p->rectangle.x + p->rectangle.width) > (n->rectangle.x + n->rectangle.width)))
			return p;
		p = p->parent;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe9df
movq $0x0, -0x8(%rbp)
jmp 0xead5
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xeacd
cmpl $0x0, -0x14(%rbp)
jne 0xea1e
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xea1e
movq -0x20(%rbp), %rax
movswl 0x1a(%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0x1a(%rcx), %ecx
cmpl %ecx, %eax
jl 0xeab2
cmpl $0x1, -0x14(%rbp)
jne 0xea42
movq -0x20(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0xea42
movq -0x20(%rbp), %rax
movswl 0x18(%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0x18(%rcx), %ecx
cmpl %ecx, %eax
jl 0xeab2
cmpl $0x2, -0x14(%rbp)
jne 0xea7a
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xea7a
movq -0x20(%rbp), %rax
movswl 0x1a(%rax), %eax
movq -0x20(%rbp), %rcx
movzwl 0x1e(%rcx), %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movswl 0x1a(%rcx), %ecx
movq -0x10(%rbp), %rdx
movzwl 0x1e(%rdx), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jg 0xeab2
cmpl $0x3, -0x14(%rbp)
jne 0xeabc
movq -0x20(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0xeabc
movq -0x20(%rbp), %rax
movswl 0x18(%rax), %eax
movq -0x20(%rbp), %rcx
movzwl 0x1c(%rcx), %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movswl 0x18(%rcx), %ecx
movq -0x10(%rbp), %rdx
movzwl 0x1c(%rdx), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jle 0xeabc
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xead5
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xe9eb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: find_by_id
bool find_by_id(uint32_t id, 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) {
			node_t *n = find_by_id_in(d->root, id);
			if (n != NULL) {
				loc->monitor = m;
				loc->desktop = d;
				loc->node = n;
				return true;
			}
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x26ba2(%rip), %rax     # 0x356f8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xebdb
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xebcb
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x8(%rbp), %esi
callq 0xebf0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xebbb
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xebdf
jmp 0xebbd
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xeb70
jmp 0xebcd
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xeb5d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: find_by_id_in
node_t *find_by_id_in(node_t *r, uint32_t id)
{
	if (r == NULL) {
		return NULL;
	} else if (r->id == id) {
		return r;
	} else {
		node_t *f = find_by_id_in(r->first_child, id);
		if (f != NULL) {
			return f;
		} else {
			return find_by_id_in(r->second_child, id);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xec10
movq $0x0, -0x8(%rbp)
jmp 0xec5e
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xec25
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xec5e
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0xebf0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xec4a
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xec5e
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0xebf0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: find_any_node
void find_any_node(coordinates_t *ref, coordinates_t *dst, node_select_t *sel)
{
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
			if (find_any_node_in(m, d, d->root, ref, dst, sel)) {
				return;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x26a6d(%rip), %rax     # 0x356f8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xecf5
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xece5
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
callq 0xed00
testb $0x1, %al
jne 0xecd3
jmp 0xecd5
jmp 0xecf5
jmp 0xecd7
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xeca5
jmp 0xece7
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xec92
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: find_any_node_in
bool find_any_node_in(monitor_t *m, desktop_t *d, node_t *n, coordinates_t *ref, coordinates_t *dst, node_select_t *sel)
{
	if (n == NULL) {
		return false;
	} else {
		coordinates_t loc = {m, d, n};
		if (node_matches(&loc, ref, sel)) {
			*dst = loc;
			return true;
		} else {
			if (find_any_node_in(m, d, n->first_child, ref, dst, sel)) {
				return true;
			} else {
				return find_any_node_in(m, d, n->second_child, ref, dst, sel);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xed30
movb $0x0, -0x1(%rbp)
jmp 0xedd3
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x23df0
testb $0x1, %al
jne 0xed5f
jmp 0xed80
movq -0x30(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xedd3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0xed00
testb $0x1, %al
jne 0xeda7
jmp 0xedad
movb $0x1, -0x1(%rbp)
jmp 0xedd3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0xed00
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: find_first_ancestor
void find_first_ancestor(coordinates_t *ref, coordinates_t *dst, node_select_t *sel)
{
	if (ref->node == NULL) {
		return;
	}

	coordinates_t loc = {ref->monitor, ref->desktop, ref->node};
	while ((loc.node = loc.node->parent) != NULL) {
		if (node_matches(&loc, ref, sel)) {
			*dst = loc;
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xee01
jmp 0xee6c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xee6c
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x23df0
testb $0x1, %al
jne 0xee4d
jmp 0xee6a
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0xee6c
jmp 0xee24
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: find_by_area
void find_by_area(area_peak_t ap, coordinates_t *ref, coordinates_t *dst, node_select_t *sel)
{
	unsigned int p_area;
	if (ap == AREA_BIGGEST) {
		p_area = 0;
	} else {
		p_area = UINT_MAX;
	}

	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 *f = first_extrema(d->root); f != NULL; f = next_leaf(f, d->root)) {
				coordinates_t loc = {m, d, f};
				if (f->vacant || !node_matches(&loc, ref, sel)) {
					continue;
				}
				unsigned int f_area = node_area(d, f);
				if ((ap == AREA_BIGGEST && f_area > p_area) || (ap == AREA_SMALLEST && f_area < p_area)) {
					*dst = loc;
					p_area = f_area;
				}
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xf056
movl $0x0, -0x24(%rbp)
jmp 0xf05d
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
leaq 0x26694(%rip), %rax     # 0x356f8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xf171
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xf15e
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xbe70
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xf14b
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
testb $0x1, 0x24(%rax)
jne 0xf0e0
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x23df0
testb $0x1, %al
jne 0xf0e2
jmp 0xf131
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xbec0
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xf100
movl -0x5c(%rbp), %eax
cmpl -0x24(%rbp), %eax
ja 0xf10e
cmpl $0x1, -0x4(%rbp)
jne 0xf12f
movl -0x5c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xf12f
movq -0x18(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x5c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xf131
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0xbf80
movq %rax, -0x40(%rbp)
jmp 0xf09e
jmp 0xf14d
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xf082
jmp 0xf160
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xf06b
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: rotate_tree_rec
void rotate_tree_rec(node_t *n, int deg)
{
	if (n == NULL || is_leaf(n) || deg == 0) {
		return;
	}

	node_t *tmp;

	if ((deg == 90 && n->split_type == TYPE_HORIZONTAL) ||
	    (deg == 270 && n->split_type == TYPE_VERTICAL) ||
	    deg == 180) {
		tmp = n->first_child;
		n->first_child = n->second_child;
		n->second_child = tmp;
		n->split_ratio = 1.0 - n->split_ratio;
	}

	if (deg != 180) {
		if (n->split_type == TYPE_HORIZONTAL) {
			n->split_type = TYPE_VERTICAL;
		} else if (n->split_type == TYPE_VERTICAL) {
			n->split_type = TYPE_HORIZONTAL;
		}
	}

	rotate_tree_rec(n->first_child, deg);
	rotate_tree_rec(n->second_child, deg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf1a9
movq -0x8(%rbp), %rdi
callq 0xb870
testb $0x1, %al
jne 0xf1a9
cmpl $0x0, -0xc(%rbp)
jne 0xf1ae
jmp 0xf275
cmpl $0x5a, -0xc(%rbp)
jne 0xf1be
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xf1da
cmpl $0x10e, -0xc(%rbp)      # imm = 0x10E
jne 0xf1d1
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4(%rax)
je 0xf1da
cmpl $0xb4, -0xc(%rbp)
jne 0xf21c
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movsd 0x1e5a2(%rip), %xmm0    # 0x2d7b0
subsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
cmpl $0xb4, -0xc(%rbp)
je 0xf255
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xf23c
movq -0x8(%rbp), %rax
movl $0x1, 0x4(%rax)
jmp 0xf253
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0xf251
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
jmp 0xf253
jmp 0xf255
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xf180
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xf180
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: rebuild_constraints_from_leaves
void rebuild_constraints_from_leaves(node_t *n)
{
	if (n == NULL || is_leaf(n)) {
		return;
	} else {
		rebuild_constraints_from_leaves(n->first_child);
		rebuild_constraints_from_leaves(n->second_child);
		update_constraints(n);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf2a2
movq -0x8(%rbp), %rdi
callq 0xb870
testb $0x1, %al
jne 0xf2a2
jmp 0xf2a4
jmp 0xf2c7
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xf280
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xf280
movq -0x8(%rbp), %rdi
callq 0xb960
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: flip_tree
void flip_tree(node_t *n, flip_t flp)
{
	if (n == NULL || is_leaf(n)) {
		return;
	}

	node_t *tmp;

	if ((flp == FLIP_HORIZONTAL && n->split_type == TYPE_HORIZONTAL) ||
	    (flp == FLIP_VERTICAL && n->split_type == TYPE_VERTICAL)) {
		tmp = n->first_child;
		n->first_child = n->second_child;
		n->second_child = tmp;
		n->split_ratio = 1.0 - n->split_ratio;
	}

	flip_tree(n->first_child, flp);
	flip_tree(n->second_child, flp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf2f5
movq -0x8(%rbp), %rdi
callq 0xb870
testb $0x1, %al
jne 0xf2f5
jmp 0xf2fa
jmp 0xf37c
cmpl $0x0, -0xc(%rbp)
jne 0xf30a
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xf31a
cmpl $0x1, -0xc(%rbp)
jne 0xf35c
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0xf35c
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movsd 0x1e462(%rip), %xmm0    # 0x2d7b0
subsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xf2d0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xf2d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: equalize_tree
void equalize_tree(node_t *n)
{
	if (n == NULL || n->vacant) {
		return;
	} else {
		n->split_ratio = split_ratio;
		equalize_tree(n->first_child);
		equalize_tree(n->second_child);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf3ad
movq -0x8(%rbp), %rax
testb $0x1, 0x24(%rax)
je 0xf3af
jmp 0xf3dd
leaq 0x26a02(%rip), %rax     # 0x35db8
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xf390
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xf390
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: balance_tree
int balance_tree(node_t *n)
{
	if (n == NULL || n->vacant) {
		return 0;
	} else if (is_leaf(n)) {
		return 1;
	} else {
		int b1 = balance_tree(n->first_child);
		int b2 = balance_tree(n->second_child);
		int b = b1 + b2;
		if (b1 > 0 && b2 > 0) {
			n->split_ratio = (double) b1 / b;
		}
		return b;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf40d
movq -0x10(%rbp), %rax
testb $0x1, 0x24(%rax)
je 0xf416
movl $0x0, -0x4(%rbp)
jmp 0xf480
movq -0x10(%rbp), %rdi
callq 0xb870
testb $0x1, %al
jne 0xf425
jmp 0xf42e
movl $0x1, -0x4(%rbp)
jmp 0xf480
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xf3f0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xf3f0
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0xf47a
cmpl $0x0, -0x18(%rbp)
jle 0xf47a
cvtsi2sdl -0x14(%rbp), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
divsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)