LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xabc4
movq 0x30(%rdi), %rcx
testq %rcx, %rcx
je 0xabc7
movq %rcx, %rax
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
jne 0xabb7
retq
xorl %eax, %eax
retq
xorl %eax, %eax
movq %rdi, %rcx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0xabc3
cmpq %rcx, 0x30(%rdi)
je 0xabc9
xorl %eax, %eax
cmpq %rcx, 0x38(%rdi)
cmoveq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xac1d
movq %rdi, %rax
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0xac02
cmpq %rsi, %rax
je 0xac02
cmpq %rax, 0x30(%rdi)
je 0xabeb
cmpq %rsi, %rax
je 0xac1d
movq 0x30(%rdi), %rcx
testq %rcx, %rcx
je 0xac1d
movq %rcx, %rax
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
jne 0xac0b
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x3, %edx
ja 0xacc9
movl %edx, %eax
leaq 0x1496c(%rip), %rcx     # 0x1f5e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movswl 0x1a(%rsi), %eax
movzwl 0x1e(%rsi), %ecx
addl %eax, %ecx
movswl 0x1a(%rdi), %eax
jmp 0xacc3
movswl 0x1a(%rdi), %eax
movzwl 0x1e(%rdi), %ecx
addl %eax, %ecx
movswl 0x1a(%rsi), %eax
jmp 0xacc3
movswl 0x18(%rdi), %eax
movzwl 0x1c(%rdi), %ecx
addl %eax, %ecx
movswl 0x18(%rsi), %eax
jmp 0xacc3
movswl 0x18(%rsi), %eax
movzwl 0x1c(%rsi), %ecx
addl %eax, %ecx
movswl 0x18(%rdi), %eax
cmpl %eax, %ecx
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xad73
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0xad73
movl %esi, %ecx
leaq 0x1490d(%rip), %rdx     # 0x1f5f8
cmpl $0x3, %esi
ja 0xad66
movslq (%rdx,%rcx,4), %r8
addq %rdx, %r8
jmpq *%r8
cmpl $0x0, 0x4(%rax)
jne 0xad66
movzwl 0x1a(%rax), %r8d
cmpw 0x1a(%rdi), %r8w
jge 0xad66
jmp 0xad75
cmpl $0x0, 0x4(%rax)
jne 0xad66
movswl 0x1a(%rax), %r8d
movzwl 0x1e(%rax), %r9d
addl %r8d, %r9d
movswl 0x1a(%rdi), %r8d
movzwl 0x1e(%rdi), %r10d
jmp 0xad4a
cmpl $0x1, 0x4(%rax)
jne 0xad66
movswl 0x18(%rax), %r8d
movzwl 0x1c(%rax), %r9d
addl %r8d, %r9d
movswl 0x18(%rdi), %r8d
movzwl 0x1c(%rdi), %r10d
addl %r8d, %r10d
cmpl %r10d, %r9d
jle 0xad66
jmp 0xad75
cmpl $0x1, 0x4(%rax)
jne 0xad66
movzwl 0x18(%rax), %r8d
cmpw 0x18(%rdi), %r8w
jl 0xad75
movq 0x40(%rax), %rax
testq %rax, %rax
jne 0xaceb
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x1e969(%rip), %rax     # 0x29708
movq (%rax), %r14
testq %r14, %r14
je 0xadd4
movq %rsi, %rbx
movl %edi, %ebp
movq 0x60(%r14), %r15
testq %r15, %r15
je 0xadcb
movq 0x30(%r15), %rdi
movl %ebp, %esi
callq 0xadf0
testq %rax, %rax
jne 0xadd8
movq 0x48(%r15), %r15
jmp 0xadb0
movq 0x78(%r14), %r14
testq %r14, %r14
jne 0xadac
xorl %eax, %eax
jmp 0xade5
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xae1a
movl %esi, %ebp
movq %rdi, %rbx
cmpl %ebp, (%rbx)
je 0xae21
movq 0x30(%rbx), %rdi
movl %ebp, %esi
callq 0xadf0
testq %rax, %rax
jne 0xae1e
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0xadfd
xorl %ebx, %ebx
jmp 0xae21
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x1e8cd(%rip), %rax     # 0x29708
movq (%rax), %r12
testq %r12, %r12
je 0xae82
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x60(%r12), %r13
testq %r13, %r13
je 0xae78
movq 0x30(%r13), %rdx
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0xae8c
testb %al, %al
jne 0xae82
movq 0x48(%r13), %r13
jmp 0xae51
movq 0x78(%r12), %r12
testq %r12, %r12
jne 0xae4c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdx, %rdx
je 0xaee2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %r13
movq %rsp, %rdi
movq %r13, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, %rsi
movq %r9, %rdx
callq 0x191e4
testb %al, %al
je 0xaee5
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
movb $0x1, %al
jmp 0xaf1d
xorl %eax, %eax
retq
movq 0x30(%rbp), %rdx
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0xae8c
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xaf1d
movq 0x38(%rbp), %rdx
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0xae8c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xaf99
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movups (%rdi), %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
movq %rax, 0x10(%r12)
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xaf8e
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x191e4
testb %al, %al
je 0xaf59
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: find_nearest_neighbor
void find_nearest_neighbor(coordinates_t *ref, coordinates_t *dst, direction_t dir, node_select_t *sel)
{
	xcb_rectangle_t rect = get_rectangle(ref->monitor, ref->desktop, ref->node);
	uint32_t md = UINT32_MAX, mr = UINT32_MAX;

	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		desktop_t *d = m->desk;
		for (node_t *f = first_extrema(d->root); f != NULL; f = next_leaf(f, d->root)) {
			coordinates_t loc = {m, d, f};
			xcb_rectangle_t r = get_rectangle(m, d, f);
			if (f == ref->node ||
			    f->client == NULL ||
			    f->hidden ||
			    is_descendant(f, ref->node) ||
			    !node_matches(&loc, ref, sel) ||
			    !on_dir_side(rect, r, dir)) {
				continue;
			}
			uint32_t fd = boundary_distance(rect, r, dir);
			uint32_t fr = history_rank(f);
			if (fd < md || (fd == md && fr < mr)) {
				md = fd;
				mr = fr;
				*dst = loc;
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x28(%rsp)
movl %edx, %r12d
movq %rsi, 0x20(%rsp)
movq %rdi, %rax
movq (%rdi), %rdi
movq 0x8(%rax), %rsi
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rdx
callq 0x970b
leaq 0x1e734(%rip), %rcx     # 0x29708
movq (%rcx), %r13
testq %r13, %r13
je 0xb13c
movq %rax, %r15
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
movl %r12d, 0xc(%rsp)
movq %rax, 0x18(%rsp)
movq 0x58(%r13), %r14
movq 0x30(%r14), %rcx
testq %rcx, %rcx
je 0xb12f
movq %rcx, %rbp
movq 0x30(%rcx), %rcx
testq %rcx, %rcx
jne 0xb005
movl %r12d, %ebx
movq %r13, 0x30(%rsp)
movq %r14, 0x38(%rsp)
movq %rbp, 0x40(%rsp)
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x970b
movq %rax, %r12
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
cmpq %rax, %rbp
je 0xb0f2
cmpq $0x0, 0x48(%rbp)
je 0xb0f2
cmpb $0x0, 0x25(%rbp)
jne 0xb0f2
testq %rax, %rax
je 0xb07f
movq %rbp, %rcx
movq 0x40(%rcx), %rcx
cmpq %rax, %rcx
je 0xb07a
testq %rcx, %rcx
jne 0xb06c
cmpq %rax, %rcx
je 0xb0f2
leaq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x191e4
testb %al, %al
je 0xb0f2
movq %r15, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x61e6
testb %al, %al
je 0xb0f2
movq 0x18(%rsp), %rdi
movq %r12, %rsi
movl 0xc(%rsp), %edx
callq 0x6171
movl %eax, %r12d
movq %rbp, %rdi
callq 0xdc49
cmpl 0x8(%rsp), %r12d
jb 0xb0d3
jne 0xb0f2
cmpl 0x4(%rsp), %eax
jae 0xb0f2
movq 0x40(%rsp), %rcx
movq 0x20(%rsp), %rdx
movq %rcx, 0x10(%rdx)
movups 0x30(%rsp), %xmm0
movups %xmm0, (%rdx)
movl %eax, 0x4(%rsp)
movl %r12d, 0x8(%rsp)
movq 0x30(%r14), %rax
movq %rbp, %rcx
movq 0x40(%rbp), %rbp
testq %rbp, %rbp
je 0xb10d
cmpq %rax, %rcx
je 0xb10d
cmpq %rcx, 0x38(%rbp)
je 0xb0f6
cmpq %rax, %rcx
movl %ebx, %r12d
je 0xb12f
movq 0x38(%rbp), %rax
testq %rax, %rax
je 0xb12f
movq %rax, %rbp
movq 0x30(%rax), %rax
testq %rax, %rax
jne 0xb119
jmp 0xb01d
movq 0x78(%r13), %r13
testq %r13, %r13
jne 0xaffd
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x10(%rsp)
movl %edi, 0x4(%rsp)
leaq 0x1e59f(%rip), %rax     # 0x29708
movq (%rax), %r12
testq %r12, %r12
je 0xb29e
movq %rcx, %r15
movq %rsi, %rbp
xorl %ecx, %ecx
movl 0x4(%rsp), %eax
negl %eax
sbbl %ecx, %ecx
movq %rcx, 0x8(%rsp)
movq 0x60(%r12), %r13
testq %r13, %r13
movq %r12, 0x18(%rsp)
je 0xb290
movq 0x30(%r13), %rax
testq %rax, %rax
je 0xb283
movq %rax, %r14
movq 0x30(%rax), %rax
testq %rax, %rax
jne 0xb1a1
jmp 0xb1d1
movq 0x38(%r14), %rax
testq %rax, %rax
je 0xb283
movq %rax, %r14
movq 0x30(%rax), %rax
testq %rax, %rax
jne 0xb1bc
movq %r12, 0x20(%rsp)
movq %r13, 0x28(%rsp)
movq %r14, 0x30(%rsp)
cmpb $0x0, 0x24(%r14)
jne 0xb25f
leaq 0x20(%rsp), %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x191e4
testb %al, %al
je 0xb25f
movl 0x4(%rsp), %eax
cmpl $0x1, %eax
sete %bl
testl %eax, %eax
movq %rbp, %r12
movq %r15, %rbp
sete %r15b
xorl %edi, %edi
movq %r13, %rsi
movq %r14, %rdx
callq 0x970b
movq %rax, %rdi
callq 0x615f
cmpl 0x8(%rsp), %eax
seta %dl
setb %cl
testb %dl, %r15b
movq %rbp, %r15
movq %r12, %rbp
movq 0x18(%rsp), %r12
jne 0xb244
andb %cl, %bl
je 0xb25f
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rdx
movq %rcx, 0x10(%rdx)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rdx)
movq %rax, 0x8(%rsp)
movq 0x30(%r13), %rax
movq %r14, %rcx
movq 0x40(%r14), %r14
testq %r14, %r14
je 0xb27a
cmpq %rax, %rcx
je 0xb27a
cmpq %rcx, 0x38(%r14)
je 0xb263
cmpq %rax, %rcx
jne 0xb1b8
movq 0x48(%r13), %r13
testq %r13, %r13
jne 0xb19d
movq 0x78(%r12), %r12
testq %r12, %r12
jne 0xb18a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xb38b
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0xb2cc
xorl %eax, %eax
jmp 0xb2d4
cmpq $0x0, 0x38(%r14)
sete %al
testl %ebx, %ebx
je 0xb384
testb %al, %al
jne 0xb384
cmpl $0x10e, %ebx            # imm = 0x10E
je 0xb327
cmpl $0xb4, %ebx
je 0xb302
cmpl $0x5a, %ebx
jne 0xb351
cmpl $0x0, 0x4(%r14)
jne 0xb351
jmp 0xb32e
movq 0x38(%r14), %rax
movq %rax, 0x30(%r14)
movq %rdi, 0x38(%r14)
movsd 0x142f2(%rip), %xmm0    # 0x1f608
subsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%r14)
movq %rax, %rdi
jmp 0xb370
cmpl $0x1, 0x4(%r14)
jne 0xb351
movq 0x38(%r14), %rax
movq %rax, 0x30(%r14)
movq %rdi, 0x38(%r14)
movsd 0x142c6(%rip), %xmm0    # 0x1f608
subsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%r14)
movq %rax, %rdi
movl 0x4(%r14), %eax
cmpl $0x1, %eax
je 0xb368
testl %eax, %eax
jne 0xb370
movl $0x1, 0x4(%r14)
jmp 0xb370
movl $0x0, 0x4(%r14)
movl %ebx, %esi
callq 0xb2ad
movq 0x38(%r14), %r14
testq %r14, %r14
jne 0xb2bf
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
testq %rdi, %rdi
je 0xb3bc
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
jne 0xb3a5
cmpq $0x0, 0x38(%rbx)
je 0xb3bc
callq 0xb38c
movq 0x38(%rbx), %rdi
callq 0xb38c
movq %rbx, %rdi
popq %rbx
jmp 0x8ebe
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xb42f
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x30(%r14), %rdi
testq %rdi, %rdi
jne 0xb3dc
cmpq $0x0, 0x38(%r14)
je 0xb428
cmpl $0x1, %ebx
je 0xb3ee
testl %ebx, %ebx
jne 0xb418
cmpl $0x0, 0x4(%r14)
jne 0xb418
jmp 0xb3f5
cmpl $0x1, 0x4(%r14)
jne 0xb418
movq 0x38(%r14), %rax
movq %rax, 0x30(%r14)
movq %rdi, 0x38(%r14)
movsd 0x141ff(%rip), %xmm0    # 0x1f608
subsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%r14)
movq %rax, %rdi
movl %ebx, %esi
callq 0xb3be
movq 0x38(%r14), %r14
testq %r14, %r14
jne 0xb3cc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xb46c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1e985(%rip), %r14     # 0x29dc8
cmpb $0x0, 0x24(%rbx)
jne 0xb465
movsd (%r14), %xmm0
movsd %xmm0, 0x8(%rbx)
movq 0x30(%rbx), %rdi
callq 0xb430
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0xb443
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
testq %rdi, %rdi
je 0xb4da
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x24(%rdi)
jne 0xb4d3
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
jne 0xb491
cmpq $0x0, 0x38(%rbx)
je 0xb4ce
callq 0xb46d
movl %eax, %r14d
movq 0x38(%rbx), %rdi
callq 0xb46d
movl %eax, %ecx
leal (%rcx,%r14), %eax
testl %r14d, %r14d
setg %dl
testl %ecx, %ecx
setg %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0xb4d3
cvtsi2sd %r14d, %xmm0
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0xb4d3
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: close_node
void close_node(node_t *n)
{
	if (n == NULL) {
		return;
	} else if (n->client != NULL) {
		if (n->client->icccm_props.delete_window) {
			send_client_message(n->id, ewmh->WM_PROTOCOLS, WM_DELETE_WINDOW);
		} else {
			xcb_kill_client(dpy, n->id);
		}
	} else {
		close_node(n->first_child);
		close_node(n->second_child);
	}
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xb825
movq %rdi, %rbx
movq 0x48(%rbx), %rax
testq %rax, %rax
jne 0xb827
movq 0x30(%rbx), %rdi
callq 0xb801
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0xb80a
popq %rbx
retq
cmpb $0x1, 0x376(%rax)
jne 0xb851
movl (%rbx), %edi
leaq 0x1e5f7(%rip), %rax     # 0x29e30
movq (%rax), %rax
movl 0xc8(%rax), %esi
leaq 0x1df3f(%rip), %rax     # 0x29788
movl (%rax), %edx
popq %rbx
jmp 0x1152f
leaq 0x1de70(%rip), %rax     # 0x296c8
movq (%rax), %rdi
movl (%rbx), %esi
popq %rbx
jmp 0x4ad0
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: kill_node
void kill_node(monitor_t *m, desktop_t *d, node_t *n)
{
	if (n == NULL) {
		return;
	}

	if (IS_RECEPTACLE(n)) {
		put_status(SBSC_MASK_NODE_REMOVE, "node_remove 0x%08X 0x%08X 0x%08X\n", m->id, d->id, n->id);
		remove_node(m, d, n);
	} else {
		for (node_t *f = first_extrema(n); f != NULL; f = next_leaf(f, n)) {
			if (f->client != NULL) {
				xcb_kill_client(dpy, f->id);
			}
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdx, %rdx
je 0xb8e9
movq %rdx, %rbx
cmpq $0x0, 0x30(%rdx)
movq %rdx, %rax
jne 0xb88e
cmpq $0x0, 0x38(%rbx)
movq %rbx, %rax
jne 0xb88e
cmpq $0x0, 0x48(%rbx)
movq %rbx, %rax
je 0xb8ef
movq %rax, %r15
movq 0x30(%rax), %rax
testq %rax, %rax
jne 0xb88e
leaq 0x1de27(%rip), %r14     # 0x296c8
cmpq $0x0, 0x48(%r15)
je 0xb8b3
movq (%r14), %rdi
movl (%r15), %esi
callq 0x4ad0
movq %r15, %rax
movq 0x40(%r15), %r15
testq %r15, %r15
je 0xb8ca
cmpq %rbx, %rax
je 0xb8ca
cmpq %rax, 0x38(%r15)
je 0xb8b3
cmpq %rbx, %rax
je 0xb8e9
movq 0x38(%r15), %rax
testq %rax, %rax
je 0xb8e9
movq %rax, %r15
movq 0x30(%rax), %rcx
movq %rcx, %rax
testq %rcx, %rcx
jne 0xb8d3
jmp 0xb8a1
popq %rbx
popq %r14
popq %r15
retq
movq %rsi, %r14
movq %rdi, %r15
movl 0x20(%rdi), %edx
movl 0x20(%rsi), %ecx
movl (%rbx), %r8d
leaq 0x13e68(%rip), %rsi     # 0x1f76d
movl $0x10000, %edi          # imm = 0x10000
xorl %eax, %eax
callq 0x1e6b8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xb924
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: remove_node
void remove_node(monitor_t *m, desktop_t *d, node_t *n)
{
	if (n == NULL) {
		return;
	}

	unlink_node(m, d, n);
	history_remove(d, n, true);
	remove_stack_node(n);
	cancel_presel_in(m, d, n);
	if (m->sticky_count > 0 && d == m->desk) {
		m->sticky_count -= sticky_count(n);
	}
	clients_count -= clients_count_in(n);
	if (is_descendant(grabbed_node, n)) {
		grabbed_node = NULL;
	}
	free_node(n);

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

	ewmh_update_client_list(false);
	ewmh_update_client_list(true);

	if (mon != NULL && d->focus == NULL) {
		if (d == mon->desk) {
			focus_node(m, d, NULL);
		} else {
			activate_node(m, d, NULL);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xba29
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb66d
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xd6b9
movq %r15, %rdi
callq 0xd088
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x90d2
movl 0x40(%r14), %ebp
testl %ebp, %ebp
je 0xb984
cmpq %rbx, 0x58(%r14)
jne 0xb984
movq %r15, %rdi
callq 0xba68
subl %eax, %ebp
movl %ebp, 0x40(%r14)
movq %r15, %rdi
callq 0xab00
leaq 0x1dd61(%rip), %rcx     # 0x296f4
subl %eax, (%rcx)
leaq 0x1e48c(%rip), %rax     # 0x29e28
movq (%rax), %rcx
testq %rcx, %rcx
je 0xb9c3
cmpq %r15, %rcx
je 0xb9bc
movq 0x40(%rcx), %rcx
cmpq %r15, %rcx
je 0xb9b7
testq %rcx, %rcx
jne 0xb9a9
cmpq %r15, %rcx
jne 0xb9c3
movq $0x0, (%rax)
movq %r15, %rdi
callq 0xba99
leaq 0x1e426(%rip), %rax     # 0x29df8
cmpb $0x1, (%rax)
jne 0xba02
cmpl $0x1, 0x24(%rbx)
je 0xba02
movq 0x30(%rbx), %rdi
movl $0x1, %esi
callq 0x97a3
cmpl $0x1, %eax
jg 0xba02
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7d6e
xorl %edi, %edi
callq 0x1e08b
movl $0x1, %edi
callq 0x1e08b
leaq 0x1dcf6(%rip), %rax     # 0x29710
movq (%rax), %rax
testq %rax, %rax
je 0xba29
cmpq $0x0, 0x38(%rbx)
je 0xba34
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpq %rbx, 0x58(%rax)
je 0xba51
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9a3d
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa308
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: free_node
void free_node(node_t *n)
{
	if (n == NULL) {
		return;
	}
	node_t *first_child = n->first_child;
	node_t *second_child = n->second_child;
	free(n->client);
	free(n);
	free_node(first_child);
	free_node(second_child);
}

// Assembly:
testq %rdi, %rdi
je 0xbad4
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %r15
movq 0x48(%rbx), %rdi
callq 0x4460
movq %rbx, %rdi
callq 0x4460
movq %r14, %rdi
callq 0xba99
movq %r15, %rbx
testq %r15, %r15
jne 0xbaa6
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: propagate_vacant_downward
void propagate_vacant_downward(monitor_t *m, desktop_t *d, node_t *n, bool value)
{
	if (n == NULL) {
		return;
	}

	set_vacant_local(m, d, n, value);

	propagate_vacant_downward(m, d, n->first_child, value);
	propagate_vacant_downward(m, d, n->second_child, value);
}

// Assembly:
testq %rdx, %rdx
je 0xc5ab
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movzbl %bl, %ebp
cmpb %bl, 0x24(%r14)
je 0xc589
movb %bl, 0x24(%r14)
testb %bl, %bl
je 0xc589
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x906b
movq 0x30(%r14), %rdx
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %ecx
callq 0xc552
movq 0x38(%r14), %r14
testq %r14, %r14
jne 0xc56d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: propagate_vacant_upward
void propagate_vacant_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));
	}

	propagate_vacant_upward(m, d, p);
}

// Assembly:
testq %rdx, %rdx
je 0xc60e
pushq %r15
pushq %r14
pushq %rbx
movq 0x40(%rdx), %r15
testq %r15, %r15
je 0xc609
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%r15), %rax
cmpb $0x1, 0x24(%rax)
jne 0xc5f4
movq 0x38(%r15), %rax
movb 0x24(%rax), %al
cmpb %al, 0x24(%r15)
je 0xc600
movb %al, 0x24(%r15)
testb %al, %al
je 0xc600
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x906b
jmp 0xc600
cmpb $0x0, 0x24(%r15)
je 0xc600
movb $0x0, 0x24(%r15)
movq 0x40(%r15), %r15
testq %r15, %r15
jne 0xc5c5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: set_layer
bool set_layer(monitor_t *m, desktop_t *d, node_t *n, stack_layer_t l)
{
	if (n == NULL || n->client == NULL || n->client->layer == l) {
		return false;
	}

	n->client->last_layer = n->client->layer;
	n->client->layer = l;

	if (l == LAYER_ABOVE) {
		n->client->wm_flags |= WM_FLAG_ABOVE;
		n->client->wm_flags &= ~WM_FLAG_BELOW;
	} else if (l == LAYER_BELOW) {
		n->client->wm_flags |= WM_FLAG_BELOW;
		n->client->wm_flags &= ~WM_FLAG_ABOVE;
	} else {
		n->client->wm_flags &= ~(WM_FLAG_ABOVE | WM_FLAG_BELOW);
	}

	ewmh_wm_state_update(n);

	put_status(SBSC_MASK_NODE_LAYER, "node_layer 0x%08X 0x%08X 0x%08X %s\n", m->id, d->id, n->id, LAYER_STR(l));

	if (d->focus == n) {
		neutralize_occluding_windows(m, d, n);
	}

	stack(d, n, (d->focus == n));

	return true;
}

// Assembly:
testq %rdx, %rdx
je 0xc64b
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x48(%rdx), %rax
testq %rax, %rax
je 0xc644
movl %ecx, %ebp
movl 0x310(%rax), %ecx
cmpl %ebp, %ecx
jne 0xc64e
xorl %eax, %eax
jmp 0xc700
xorl %eax, %eax
retq
movq %rsi, %r14
movq %rdi, %r15
movl %ecx, 0x314(%rax)
movl %ebp, 0x310(%rax)
movl $0xfffff9ff, %ecx       # imm = 0xFFFFF9FF
andl 0x378(%rax), %ecx
testl %ebp, %ebp
je 0xc67c
cmpl $0x2, %ebp
jne 0xc682
orl $0x200, %ecx            # imm = 0x200
jmp 0xc682
orl $0x400, %ecx            # imm = 0x400
movl %ecx, 0x378(%rax)
movq %rbx, %rdi
callq 0x1e1d3
movl 0x20(%r15), %edx
movl 0x20(%r14), %ecx
movl (%rbx), %r8d
cmpl $0x1, %ebp
leaq 0x1466f(%rip), %rax     # 0x20d14
leaq 0x14670(%rip), %rsi     # 0x20d1c
cmoveq %rax, %rsi
testl %ebp, %ebp
leaq 0x14654(%rip), %r9      # 0x20d0d
cmovneq %rsi, %r9
leaq 0x13139(%rip), %rsi     # 0x1f7fd
movl $0x4000000, %edi        # imm = 0x4000000
xorl %eax, %eax
callq 0x1e6b8
movq 0x38(%r14), %rax
cmpq %rbx, %rax
jne 0xc6eb
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9c8d
movq 0x38(%r14), %rax
xorl %edx, %edx
cmpq %rbx, %rax
sete %dl
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd303
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: set_floating
void set_floating(monitor_t *m, desktop_t *d, node_t *n, bool value)
{
	if (n == NULL) {
		return;
	}

	cancel_presel(m, d, n);
	if (!n->hidden) {
		set_vacant(m, d, n, value);
	}

	if (!value && d->focus == n) {
		neutralize_occluding_windows(m, d, n);
	}

	stack(d, n, (d->focus == n));
}

// Assembly:
testq %rdx, %rdx
je 0xc984
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x906b
cmpb $0x0, 0x25(%rbx)
jne 0xc94d
movzbl %bpl, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc523
testb %bpl, %bpl
jne 0xc966
cmpq %rbx, 0x38(%r14)
jne 0xc966
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9c8d
xorl %edx, %edx
cmpq %rbx, 0x38(%r14)
sete %dl
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd303
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: set_fullscreen
void set_fullscreen(monitor_t *m, desktop_t *d, node_t *n, bool value)
{
	if (n == NULL) {
		return;
	}

	client_t *c = n->client;

	cancel_presel(m, d, n);
	if (!n->hidden) {
		set_vacant(m, d, n, value);
	}

	if (value) {
		c->wm_flags |= WM_FLAG_FULLSCREEN;
	} else {
		c->wm_flags &= ~WM_FLAG_FULLSCREEN;
		if (d->focus == n) {
			neutralize_occluding_windows(m, d, n);
		}
	}

	ewmh_wm_state_update(n);
	stack(d, n, (d->focus == n));
}

// Assembly:
testq %rdx, %rdx
je 0xc9da
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rdx), %r12
callq 0x906b
cmpb $0x0, 0x25(%rbx)
jne 0xc9be
movzbl %bpl, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc523
movl 0x378(%r12), %eax
testb %bpl, %bpl
je 0xc9db
orl $0x100, %eax            # imm = 0x100
movl %eax, 0x378(%r12)
jmp 0xc9fc
retq
andl $0xfffffeff, %eax       # imm = 0xFFFFFEFF
movl %eax, 0x378(%r12)
cmpq %rbx, 0x38(%r14)
jne 0xc9fc
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9c8d
movq %rbx, %rdi
callq 0x1e1d3
xorl %edx, %edx
cmpq %rbx, 0x38(%r14)
sete %dl
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd303
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: set_hidden_local
void set_hidden_local(monitor_t *m, desktop_t *d, node_t *n, bool value)
{
	if (n->hidden == value) {
		return;
	}

	n->hidden = value;

	if (n->client != NULL) {
		if (n->client->shown) {
			window_set_visibility(n->id, !value);
		}

		if (IS_TILED(n->client)) {
			set_vacant(m, d, n, value);
		}

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

		ewmh_wm_state_update(n);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
cmpb %bpl, 0x25(%rdx)
je 0xcaa9
movq %rdx, %rbx
movb %bpl, 0x25(%rdx)
movq 0x48(%rdx), %rax
testq %rax, %rax
je 0xcaa9
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x1, 0x305(%rax)
jne 0xca60
movl (%rbx), %edi
movl %ebp, %eax
xorb $0x1, %al
movzbl %al, %esi
callq 0x11398
movq 0x48(%rbx), %rax
cmpl $0x1, 0x308(%rax)
movzbl %bpl, %ebp
ja 0xca7d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xc523
movq 0x48(%rbx), %rax
movl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
andl 0x378(%rax), %ecx
shll $0x7, %ebp
orl %ecx, %ebp
movl %ebp, 0x378(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1e1d3
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: set_hidden
void set_hidden(monitor_t *m, desktop_t *d, node_t *n, bool value)
{
	if (n == NULL || n->hidden == value) {
		return;
	}

	bool held_focus = is_descendant(d->focus, n);

	propagate_hidden_downward(m, d, n, value);
	propagate_hidden_upward(m, d, n);

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

	if (held_focus || d->focus == NULL) {
		if (d->focus != NULL) {
			d->focus = NULL;
			draw_border(n, false, (mon == m));
		}
		if (d == mon->desk) {
			focus_node(m, d, d->focus);
		} else {
			activate_node(m, d, d->focus);
		}
	}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xcc54
movl %ecx, %ebp
movq %rdx, %r15
cmpb %bpl, 0x25(%rdx)
je 0xcc54
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rsi), %rcx
testq %rcx, %rcx
je 0xcb08
movq %r15, %rax
cmpq %r15, %rcx
je 0xcaff
movq %rcx, %rax
movq 0x40(%rax), %rax
cmpq %r15, %rax
je 0xcaff
testq %rax, %rax
jne 0xcaf1
cmpq %r15, %rax
sete %r13b
jmp 0xcb0b
xorl %r13d, %r13d
movzbl %bpl, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xcc63
movq 0x40(%r15), %r12
testq %r12, %r12
je 0xcb55
movq 0x30(%r12), %rax
cmpb $0x1, 0x25(%rax)
jne 0xcb3b
movq 0x38(%r12), %rax
movb 0x25(%rax), %al
jmp 0xcb3d
xorl %eax, %eax
movzbl %al, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xca20
movq 0x40(%r12), %r12
jmp 0xcb21
movl 0x20(%r14), %edx
movl 0x20(%rbx), %ecx
movl (%r15), %r8d
leaq 0x13f63(%rip), %rax     # 0x20ac9
leaq 0x12d2d(%rip), %r9      # 0x1f89a
testb %bpl, %bpl
cmovneq %rax, %r9
leaq 0x12cf5(%rip), %rsi     # 0x1f870
movl $0x2000000, %edi        # imm = 0x2000000
xorl %eax, %eax
callq 0x1e6b8
movq 0x38(%rbx), %rax
testb %r13b, %r13b
je 0xcbb8
testq %rax, %rax
je 0xcbbd
movq $0x0, 0x38(%rbx)
leaq 0x1cb6c(%rip), %rax     # 0x29710
xorl %edx, %edx
cmpq %r14, (%rax)
sete %dl
movq %r15, %rdi
xorl %esi, %esi
callq 0xff61
jmp 0xcbbd
testq %rax, %rax
jne 0xcbe9
leaq 0x1cb4c(%rip), %rax     # 0x29710
movq (%rax), %rax
movq 0x38(%rbx), %rdx
cmpq %rbx, 0x58(%rax)
je 0xcbde
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9a3d
jmp 0xcbe9
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa308
leaq 0x1d208(%rip), %rax     # 0x29df8
cmpb $0x1, (%rax)
jne 0xcc54
movl 0x24(%rbx), %eax
testb %bpl, %bpl
je 0xcc1c
cmpl $0x1, %eax
je 0xcc54
movq 0x30(%rbx), %rdi
movl $0x1, %ebp
movl $0x1, %esi
callq 0x97a3
cmpl $0x2, %eax
jl 0xcc37
jmp 0xcc54
cmpl $0x1, %eax
jne 0xcc54
movq 0x30(%rbx), %rdi
movl $0x1, %esi
callq 0x97a3
cmpl $0x2, %eax
jl 0xcc54
movl 0x28(%rbx), %ebp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7d6e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: propagate_hidden_downward
void propagate_hidden_downward(monitor_t *m, desktop_t *d, node_t *n, bool value)
{
	if (n == NULL) {
		return;
	}

	set_hidden_local(m, d, n, value);

	propagate_hidden_downward(m, d, n->first_child, value);
	propagate_hidden_downward(m, d, n->second_child, value);
}

// Assembly:
testq %rdx, %rdx
je 0xccaf
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movzbl %cl, %ebp
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xca20
movq 0x30(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0xcc63
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0xcc7b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: propagate_hidden_upward
void propagate_hidden_upward(monitor_t *m, desktop_t *d, node_t *n)
{
	if (n == NULL) {
		return;
	}

	node_t *p = n->parent;

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

	propagate_hidden_upward(m, d, p);
}

// Assembly:
testq %rdx, %rdx
je 0xccfd
pushq %r15
pushq %r14
pushq %rbx
movq 0x40(%rdx), %r15
testq %r15, %r15
je 0xccf8
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%r15), %rax
cmpb $0x1, 0x25(%rax)
jne 0xccdc
movq 0x38(%r15), %rax
movb 0x25(%rax), %al
jmp 0xccde
xorl %eax, %eax
movzbl %al, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xca20
movq 0x40(%r15), %r15
testq %r15, %r15
jne 0xccc9
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: set_sticky
void set_sticky(monitor_t *m, desktop_t *d, node_t *n, bool value)
{
	if (n == NULL || n->sticky == value) {
		return;
	}

	if (d != m->desk) {
		transfer_node(m, d, n, m, m->desk, m->desk->focus, false);
	}

	n->sticky = value;

	if (value) {
		m->sticky_count++;
	} else {
		m->sticky_count--;
	}

	if (n->client != NULL) {
		if (value) {
			n->client->wm_flags |= WM_FLAG_STICKY;
		} else {
			n->client->wm_flags &= ~WM_FLAG_STICKY;
		}
		ewmh_wm_state_update(n);
	}

	put_status(SBSC_MASK_NODE_FLAG, "node_flag 0x%08X 0x%08X 0x%08X sticky %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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xcdc8
movl %ecx, %ebp
movq %rdx, %rbx
cmpb %bpl, 0x26(%rdx)
je 0xcdc8
movq %rsi, %r15
movq %rdi, %r14
movq 0x58(%rdi), %r8
cmpq %rsi, %r8
je 0xcd48
movq 0x38(%r8), %r9
movl $0x0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x9e6b
movb %bpl, 0x26(%rbx)
movl 0x40(%r14), %eax
testb %bpl, %bpl
je 0xcd6d
incl %eax
movl %eax, 0x40(%r14)
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0xcd8b
orb $0x2, 0x378(%rax)
jmp 0xcd83
decl %eax
movl %eax, 0x40(%r14)
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0xcd8b
andb $-0x3, 0x378(%rax)
movq %rbx, %rdi
callq 0x1e1d3
movl 0x20(%r14), %edx
movl 0x20(%r15), %ecx
movl (%rbx), %r8d
leaq 0x13d2c(%rip), %rax     # 0x20ac9
leaq 0x12af6(%rip), %r9      # 0x1f89a
testb %bpl, %bpl
cmovneq %rax, %r9
leaq 0x12aec(%rip), %rsi     # 0x1f89e
movl $0x2000000, %edi        # imm = 0x2000000
xorl %eax, %eax
callq 0x1e6b8
movq 0x58(%r14), %rax
cmpq %rbx, 0x38(%rax)
je 0xcdd3
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1e6b8
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: set_private
void set_private(monitor_t *m, desktop_t *d, node_t *n, bool value)
{
	if (n == NULL || n->private == value) {
		return;
	}

	n->private = value;

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xce3c
movq %rdx, %rbx
cmpb %cl, 0x27(%rdx)
je 0xce3c
movq %rdi, %r14
movb %cl, 0x27(%rbx)
movl 0x20(%rdi), %edx
movl 0x20(%rsi), %eax
movl (%rbx), %r8d
leaq 0x13cb9(%rip), %rsi     # 0x20ac9
leaq 0x12a83(%rip), %r9      # 0x1f89a
testb %cl, %cl
cmovneq %rsi, %r9
leaq 0x12aa4(%rip), %rsi     # 0x1f8c8
movl $0x2000000, %edi        # imm = 0x2000000
movl %eax, %ecx
xorl %eax, %eax
callq 0x1e6b8
movq 0x58(%r14), %rax
cmpq %rbx, 0x38(%rax)
je 0xce44
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1e6b8
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: set_locked
void set_locked(monitor_t *m, desktop_t *d, node_t *n, bool value)
{
	if (n == NULL || n->locked == value) {
		return;
	}

	n->locked = value;

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xceaa
movq %rdx, %rbx
cmpb %cl, 0x28(%rdx)
je 0xceaa
movq %rdi, %r14
movb %cl, 0x28(%rbx)
movl 0x20(%rdi), %edx
movl 0x20(%rsi), %eax
movl (%rbx), %r8d
leaq 0x13c4b(%rip), %rsi     # 0x20ac9
leaq 0x12a15(%rip), %r9      # 0x1f89a
testb %cl, %cl
cmovneq %rsi, %r9
leaq 0x12a61(%rip), %rsi     # 0x1f8f3
movl $0x2000000, %edi        # imm = 0x2000000
movl %eax, %ecx
xorl %eax, %eax
callq 0x1e6b8
movq 0x58(%r14), %rax
cmpq %rbx, 0x38(%rax)
je 0xceb2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1e6b8
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: listen_enter_notify
void listen_enter_notify(node_t *n, bool enable)
{
	uint32_t mask = CLIENT_EVENT_MASK | (enable ? XCB_EVENT_MASK_ENTER_WINDOW : 0);
	for (node_t *f = first_extrema(n); f != NULL; f = next_leaf(f, n)) {
		if (f->client == NULL) {
			continue;
		}
		xcb_change_window_attributes(dpy, f->id, XCB_CW_EVENT_MASK, &mask);
		if (f->presel != NULL) {
			xcb_change_window_attributes(dpy, f->presel->feedback, XCB_CW_EVENT_MASK, &mask);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
shll $0x4, %esi
orl $0x600000, %esi         # imm = 0x600000
movl %esi, 0x4(%rsp)
movq %rdi, %rax
testq %rax, %rax
je 0xcf73
movq %rax, %r12
movq 0x30(%rax), %rax
testq %rax, %rax
jne 0xcee0
leaq 0x1c7cc(%rip), %r15     # 0x296c8
leaq 0x4(%rsp), %r14
cmpq $0x0, 0x48(%r12)
je 0xcf3a
movq (%r15), %rdi
movl (%r12), %esi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rcx
callq 0x4700
movq 0x10(%r12), %rax
testq %rax, %rax
je 0xcf3a
movq (%r15), %rdi
movl 0xc(%rax), %esi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rcx
callq 0x4700
movq %r12, %rax
movq 0x40(%r12), %r12
testq %r12, %r12
je 0xcf53
cmpq %rbx, %rax
je 0xcf53
cmpq %rax, 0x38(%r12)
je 0xcf3a
cmpq %rbx, %rax
je 0xcf73
movq 0x38(%r12), %rax
testq %rax, %rax
je 0xcf73
movq %rax, %r12
movq 0x30(%rax), %rcx
movq %rcx, %rax
testq %rcx, %rcx
jne 0xcf5d
jmp 0xcf01
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/tree.c
// Function: regenerate_ids_in
void regenerate_ids_in(node_t *n)
{
	if (n == NULL || n->client != NULL) {
		return;
	}
	n->id = xcb_generate_id(dpy);
	regenerate_ids_in(n->first_child);
	regenerate_ids_in(n->second_child);
}

// Assembly:
testq %rdi, %rdi
je 0xcfbc
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1c736(%rip), %r14     # 0x296c8
cmpq $0x0, 0x48(%rbx)
jne 0xcfb5
movq (%r14), %rdi
callq 0x4920
movl %eax, (%rbx)
movq 0x30(%rbx), %rdi
callq 0xcf7f
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0xcf92
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/stack.c
// Function: stack_insert_after
void stack_insert_after(stacking_list_t *a, node_t *n)
{
	stacking_list_t *s = make_stack(n);
	if (a == NULL) {
		stack_head = stack_tail = s;
	} else {
		if (a->node == n) {
			free(s);
			return;
		}
		remove_stack_node(n);
		stacking_list_t *b = a->next;
		if (b != NULL) {
			b->prev = s;
		}
		s->next = b;
		s->prev = a;
		a->next = s;
		if (stack_tail == a) {
			stack_tail = s;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x1, %edi
movl $0x18, %esi
callq 0x48b0
movq %rax, %rbx
movq %r15, (%rax)
testq %r14, %r14
je 0xd061
cmpq %r15, (%r14)
je 0xd07b
movq %r15, %rdi
callq 0xd088
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xd047
movq %rbx, 0x8(%rax)
movq %rax, 0x10(%rbx)
movq %r14, 0x8(%rbx)
movq %rbx, 0x10(%r14)
leaq 0x1c6e6(%rip), %rax     # 0x29740
cmpq %r14, (%rax)
jne 0xd075
jmp 0xd072
leaq 0x1c6d8(%rip), %rax     # 0x29740
movq %rbx, (%rax)
leaq 0x1c6d6(%rip), %rax     # 0x29748
movq %rbx, (%rax)
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4460
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/stack.c
// Function: remove_stack_node
void remove_stack_node(node_t *n)
{
	for (node_t *f = first_extrema(n); f != NULL; f = next_leaf(f, n)) {
		for (stacking_list_t *s = stack_head; s != NULL; s = s->next) {
			if (s->node == f) {
				remove_stack(s);
				break;
			}
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x920c
testq %rax, %rax
je 0xd0cf
movq %rax, %r14
leaq 0x1c6a4(%rip), %r15     # 0x29748
movq (%r15), %rdi
testq %rdi, %rdi
je 0xd0bc
cmpq %r14, (%rdi)
je 0xd0b7
movq 0x10(%rdi), %rdi
jmp 0xd0a7
callq 0xd155
movq %r14, %rdi
movq %rbx, %rsi
callq 0x926e
movq %rax, %r14
testq %rax, %rax
jne 0xd0a4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/stack.c
// Function: stack_insert_before
void stack_insert_before(stacking_list_t *a, node_t *n)
{
	stacking_list_t *s = make_stack(n);
	if (a == NULL) {
		stack_head = stack_tail = s;
	} else {
		if (a->node == n) {
			free(s);
			return;
		}
		remove_stack_node(n);
		stacking_list_t *b = a->prev;
		if (b != NULL) {
			b->next = s;
		}
		s->prev = b;
		s->next = a;
		a->prev = s;
		if (stack_head == a) {
			stack_head = s;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x1, %edi
movl $0x18, %esi
callq 0x48b0
movq %rax, %rbx
movq %r15, (%rax)
testq %r14, %r14
je 0xd12e
cmpq %r15, (%r14)
je 0xd148
movq %r15, %rdi
callq 0xd088
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xd114
movq %rbx, 0x10(%rax)
movq %rax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, 0x8(%r14)
leaq 0x1c621(%rip), %rax     # 0x29748
cmpq %r14, (%rax)
jne 0xd142
jmp 0xd13f
leaq 0x1c60b(%rip), %rax     # 0x29740
movq %rbx, (%rax)
leaq 0x1c609(%rip), %rax     # 0x29748
movq %rbx, (%rax)
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4460
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/stack.c
// Function: remove_stack
void remove_stack(stacking_list_t *s)
{
	if (s == NULL) {
		return;
	}
	stacking_list_t *a = s->prev;
	stacking_list_t *b = s->next;
	if (a != NULL) {
		a->next = b;
	}
	if (b != NULL) {
		b->prev = a;
	}
	if (s == stack_head) {
		stack_head = b;
	}
	if (s == stack_tail) {
		stack_tail = a;
	}
	free(s);
}

// Assembly:
testq %rdi, %rdi
je 0xd19b
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
testq %rax, %rax
je 0xd16b
movq %rcx, 0x10(%rax)
testq %rcx, %rcx
je 0xd174
movq %rax, 0x8(%rcx)
leaq 0x1c5cd(%rip), %rdx     # 0x29748
cmpq %rdi, (%rdx)
jne 0xd183
movq %rcx, (%rdx)
leaq 0x1c5b6(%rip), %rcx     # 0x29740
cmpq %rdi, (%rcx)
jne 0x4460
movq %rax, (%rcx)
jmp 0x4460
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]bspwm/src/stack.c
// Function: limit_above
stacking_list_t *limit_above(node_t *n)
{
	stacking_list_t *s = stack_head;
	while (s != NULL && stack_cmp(n->client, s->node->client) >= 0) {
		s = s->next;
	}
	if (s == NULL) {
		s = stack_tail;
	}
	if (s->node == n) {
		s = s->prev;
	}
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x1c4f3(%rip), %rax     # 0x29748
movq (%rax), %rbx
testq %rbx, %rbx
je 0xd27e
movq 0x48(%r14), %r15
movq (%rbx), %r12
movq 0x48(%r12), %rsi
movq %r15, %rdi
callq 0xd1d2
testl %eax, %eax
js 0xd28b
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0xd261
leaq 0x1c4bb(%rip), %rax     # 0x29740
movq (%rax), %rbx
movq (%rbx), %r12
cmpq %r14, %r12
jne 0xd294
movq 0x8(%rbx), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq