LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xf995
jmp 0xfa0d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xf9f1
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
testb $0x1, 0x376(%rax)
je 0xf9d7
movq -0x8(%rbp), %rax
movl (%rax), %edi
leaq 0x26462(%rip), %rax     # 0x35e20
movq (%rax), %rax
movl 0xc8(%rax), %esi
leaq 0x25daa(%rip), %rax     # 0x35778
movl (%rax), %edx
callq 0x18980
jmp 0xf9ef
leaq 0x25cda(%rip), %rax     # 0x356b8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x4aa0
movl %eax, -0xc(%rbp)
jmp 0xfa0b
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xf980
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xf980
jmp 0xfa0d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xfa40
jmp 0xfae3
movq -0x18(%rbp), %rdi
callq 0xb870
testb $0x1, %al
jne 0xfa4f
jmp 0xfa95
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0xfa95
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x18(%rbp), %rax
movl (%rax), %r8d
movl $0x10000, %edi          # imm = 0x10000
leaq 0x1de9e(%rip), %rsi     # 0x2d919
movb $0x0, %al
callq 0x2c0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xfaf0
jmp 0xfae3
movq -0x18(%rbp), %rdi
callq 0xbe70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xfae1
movq -0x20(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xfacc
leaq 0x25bfd(%rip), %rax     # 0x356b8
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x4aa0
movl %eax, -0x24(%rbp)
jmp 0xface
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xbf80
movq %rax, -0x20(%rbp)
jmp 0xfaa2
jmp 0xfae3
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xfb10
jmp 0xfc6d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf740
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x12710
movq -0x18(%rbp), %rdi
callq 0x11cd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xbd00
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jbe 0xfb7c
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x58(%rcx), %rax
jne 0xfb7c
movq -0x18(%rbp), %rdi
callq 0xfc80
movl %eax, %edx
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x40(%rax)
movq -0x18(%rbp), %rdi
callq 0xe510
leaq 0x25b58(%rip), %rcx     # 0x356e4
movl (%rcx), %ecx
subl %eax, %ecx
leaq 0x25b4d(%rip), %rax     # 0x356e4
movl %ecx, (%rax)
leaq 0x26278(%rip), %rax     # 0x35e18
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xd040
testb $0x1, %al
jne 0xfbb2
jmp 0xfbc0
leaq 0x2625f(%rip), %rax     # 0x35e18
movq $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0xfcf0
leaq 0x26218(%rip), %rax     # 0x35de8
testb $0x1, (%rax)
je 0xfc0a
movq -0x10(%rbp), %rax
cmpl $0x1, 0x24(%rax)
je 0xfc0a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl $0x1, %esi
callq 0xc8d0
cmpl $0x1, %eax
jg 0xfc0a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x9e80
xorl %edi, %edi
callq 0x2b630
movl $0x1, %edi
callq 0x2b630
leaq 0x25ade(%rip), %rax     # 0x35700
cmpq $0x0, (%rax)
je 0xfc6d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xfc6d
movq -0x10(%rbp), %rax
leaq 0x25ac2(%rip), %rcx     # 0x35700
movq (%rcx), %rcx
cmpq 0x58(%rcx), %rax
jne 0xfc5a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xd720
jmp 0xfc6b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xccb0
jmp 0xfc6d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xfd05
jmp 0xfd45
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x4450
movq -0x8(%rbp), %rdi
callq 0x4450
movq -0x10(%rbp), %rdi
callq 0xfcf0
movq -0x18(%rbp), %rdi
callq 0xfcf0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: set_vacant
void set_vacant(monitor_t *m, desktop_t *d, node_t *n, bool value)
{
	if (n->vacant == value) {
		return;
	}

	propagate_vacant_downward(m, d, n, value);
	propagate_vacant_upward(m, d, n);
}

// 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)
movq -0x18(%rbp), %rax
movb 0x24(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x19(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x10aa6
jmp 0x10ad0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x10ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10b60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
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)
jne 0x10b04
jmp 0x10b57
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x10c00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x10ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x10ae0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x10b7d
jmp 0x10bf4
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x10be3
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 0x10bc9
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), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10b60
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/tree.c
// Function: set_vacant_local
void set_vacant_local(monitor_t *m, desktop_t *d, node_t *n, bool value)
{
	if (n->vacant == value) {
		return;
	}

	n->vacant = value;

	if (value) {
		cancel_presel(m, d, n);
	}
}

// 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)
movq -0x18(%rbp), %rax
movb 0x24(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x19(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x10c36
jmp 0x10c5a
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x24(%rax)
testb $0x1, -0x19(%rbp)
je 0x10c5a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xbc60
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
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)
jne 0x111d4
jmp 0x1124f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xbc60
movq -0x18(%rbp), %rax
testb $0x1, 0x25(%rax)
jne 0x11208
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x10a70
testb $0x1, -0x19(%rbp)
jne 0x1122d
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x1122d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xcf30
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq -0x18(%rbp), %rax
sete %al
movzbl %al, %edx
andl $0x1, %edx
callq 0x120e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %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)
jne 0x11287
jmp 0x11347
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xbc60
movq -0x18(%rbp), %rax
testb $0x1, 0x25(%rax)
jne 0x112c7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x10a70
testb $0x1, -0x19(%rbp)
je 0x112e5
movq -0x28(%rbp), %rax
movl 0x378(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x378(%rax)
jmp 0x1131c
movq -0x28(%rbp), %rax
movl 0x378(%rax), %ecx
andl $0xfffffeff, %ecx       # imm = 0xFFFFFEFF
movl %ecx, 0x378(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x1131a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xcf30
jmp 0x1131c
movq -0x18(%rbp), %rdi
callq 0x2b810
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq -0x18(%rbp), %rax
sete %al
movzbl %al, %edx
andl $0x1, %edx
callq 0x120e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
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)
movq -0x18(%rbp), %rax
movb 0x25(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x19(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x11389
jmp 0x1144c
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x25(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x1144c
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
testb $0x1, 0x305(%rax)
je 0x113cc
movq -0x18(%rbp), %rax
movl (%rax), %edi
movb -0x19(%rbp), %al
xorb $-0x1, %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x187d0
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
cmpl $0x0, 0x308(%rax)
je 0x113ee
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
cmpl $0x1, 0x308(%rax)
jne 0x11407
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x10a70
testb $0x1, -0x19(%rbp)
je 0x11429
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movl 0x378(%rax), %ecx
orl $0x80, %ecx
movl %ecx, 0x378(%rax)
jmp 0x11443
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movl 0x378(%rax), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
movl %ecx, 0x378(%rax)
movq -0x18(%rbp), %rdi
callq 0x2b810
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
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)
jne 0x11664
jmp 0x116b7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x11350
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x11640
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x11640
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x116dd
jmp 0x11754
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x11743
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, 0x25(%rcx)
movb %al, -0x21(%rbp)
je 0x11729
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movb 0x25(%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 0x11350
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x116c0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %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 0x1179b
movq -0x18(%rbp), %rax
movb 0x26(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x19(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x117a0
jmp 0x118b9
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x58(%rcx), %rax
je 0x117e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x58(%rax), %r8
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x38(%rax), %r9
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0xd180
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x26(%rax)
testb $0x1, -0x19(%rbp)
je 0x11802
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
jmp 0x1180f
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x40(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x11859
testb $0x1, -0x19(%rbp)
je 0x11839
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movl 0x378(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x378(%rax)
jmp 0x11850
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movl 0x378(%rax), %ecx
andl $-0x3, %ecx
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 0x1c1cd(%rip), %r9      # 0x2da46
leaq 0x1d427(%rip), %rax     # 0x2eca7
testb $0x1, %sil
cmovneq %rax, %r9
movl $0x2000000, %edi        # imm = 0x2000000
leaq 0x1c1b6(%rip), %rsi     # 0x2da4a
movb $0x0, %al
callq 0x2c0b0
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
cmpq 0x38(%rcx), %rax
jne 0x118b9
movl $0x1, %edi
movb $0x0, %al
callq 0x2c0b0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %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 0x118fb
movq -0x18(%rbp), %rax
movb 0x27(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x19(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x118fd
jmp 0x1196a
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x27(%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 0x1c11c(%rip), %r9      # 0x2da46
leaq 0x1d376(%rip), %rax     # 0x2eca7
testb $0x1, %sil
cmovneq %rax, %r9
movl $0x2000000, %edi        # imm = 0x2000000
leaq 0x1c12f(%rip), %rsi     # 0x2da74
movb $0x0, %al
callq 0x2c0b0
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
cmpq 0x38(%rcx), %rax
jne 0x1196a
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: 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 %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 0x119ab
movq -0x18(%rbp), %rax
movb 0x28(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x19(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x119ad
jmp 0x11a1a
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x28(%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 0x1c06c(%rip), %r9      # 0x2da46
leaq 0x1d2c6(%rip), %rax     # 0x2eca7
testb $0x1, %sil
cmovneq %rax, %r9
movl $0x2000000, %edi        # imm = 0x2000000
leaq 0x1c0aa(%rip), %rsi     # 0x2da9f
movb $0x0, %al
callq 0x2c0b0
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
cmpq 0x38(%rcx), %rax
jne 0x11a1a
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: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %dl
xorl %eax, %eax
movl $0x10, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
orl $0x600000, %eax         # imm = 0x600000
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbe70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x11ad4
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x11a6d
jmp 0x11ac1
leaq 0x23c44(%rip), %rax     # 0x356b8
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl $0x800, %edx            # imm = 0x800
leaq -0x10(%rbp), %rcx
callq 0x46e0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x11abf
leaq 0x23c18(%rip), %rax     # 0x356b8
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rax), %esi
movl $0x800, %edx            # imm = 0x800
leaq -0x10(%rbp), %rcx
callq 0x46e0
movl %eax, -0x20(%rbp)
jmp 0x11ac1
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xbf80
movq %rax, -0x18(%rbp)
jmp 0x11a59
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11afe
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x11b00
jmp 0x11b31
leaq 0x23bb1(%rip), %rax     # 0x356b8
movq (%rax), %rdi
callq 0x4900
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x11ae0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x11ae0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/stack.c
// Function: make_stack
stacking_list_t *make_stack(node_t *n)
{
	stacking_list_t *s = calloc(1, sizeof(stacking_list_t));
	s->node = n;
	s->prev = s->next = NULL;
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x4890
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11bb0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11c41
movq -0x18(%rbp), %rcx
leaq 0x23b01(%rip), %rax     # 0x35730
movq %rcx, (%rax)
leaq 0x23aff(%rip), %rax     # 0x35738
movq %rcx, (%rax)
jmp 0x11cc5
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x11c59
movq -0x18(%rbp), %rdi
callq 0x4450
jmp 0x11cc5
movq -0x10(%rbp), %rdi
callq 0x11cd0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x11c81
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0x23a84(%rip), %rax     # 0x35730
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x11cc3
movq -0x18(%rbp), %rcx
leaq 0x23a70(%rip), %rax     # 0x35730
movq %rcx, (%rax)
jmp 0x11cc5
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbe70
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11d42
leaq 0x23a41(%rip), %rax     # 0x35738
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x11d2d
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x11d1d
movq -0x18(%rbp), %rdi
callq 0x11e20
jmp 0x11d2d
jmp 0x11d1f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x11cfe
jmp 0x11d2f
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xbf80
movq %rax, -0x10(%rbp)
jmp 0x11ce9
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11bb0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11d91
movq -0x18(%rbp), %rcx
leaq 0x239b1(%rip), %rax     # 0x35730
movq %rcx, (%rax)
leaq 0x239af(%rip), %rax     # 0x35738
movq %rcx, (%rax)
jmp 0x11e15
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x11da9
movq -0x18(%rbp), %rdi
callq 0x4450
jmp 0x11e15
movq -0x10(%rbp), %rdi
callq 0x11cd0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x11dd1
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x2393c(%rip), %rax     # 0x35738
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x11e13
movq -0x18(%rbp), %rcx
leaq 0x23928(%rip), %rax     # 0x35738
movq %rcx, (%rax)
jmp 0x11e15
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11e38
jmp 0x11ebb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11e63
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x11e76
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
leaq 0x238b7(%rip), %rcx     # 0x35738
cmpq (%rcx), %rax
jne 0x11e94
movq -0x18(%rbp), %rcx
leaq 0x238a7(%rip), %rax     # 0x35738
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
leaq 0x23891(%rip), %rcx     # 0x35730
cmpq (%rcx), %rax
jne 0x11eb2
movq -0x10(%rbp), %rcx
leaq 0x23881(%rip), %rax     # 0x35730
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x4450
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x23785(%rip), %rax     # 0x35738
movq (%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x11fe7
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rsi
callq 0x11f60
cmpl $0x0, %eax
setge %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x11ff0
jmp 0x11ffe
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x11fba
cmpq $0x0, -0x10(%rbp)
jne 0x12013
leaq 0x23724(%rip), %rax     # 0x35730
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x1202c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/stack.c
// Function: limit_below
stacking_list_t *limit_below(node_t *n)
{
	stacking_list_t *s = stack_tail;
	while (s != NULL && stack_cmp(n->client, s->node->client) <= 0) {
		s = s->prev;
	}
	if (s == NULL) {
		s = stack_head;
	}
	if (s->node == n) {
		s = s->next;
	}
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x236dd(%rip), %rax     # 0x35730
movq (%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x12087
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rsi
callq 0x11f60
cmpl $0x0, %eax
setle %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x12090
jmp 0x1209e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1205a
cmpq $0x0, -0x10(%rbp)
jne 0x120b3
leaq 0x2368c(%rip), %rax     # 0x35738
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x120cc
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/stack.c
// Function: stack
void stack(desktop_t *d, node_t *n, bool focused)
{
	for (node_t *f = first_extrema(n); f != NULL; f = next_leaf(f, n)) {
		if (f->client == NULL || (IS_FLOATING(f->client) && !auto_raise)) {
			continue;
		}

		if (stack_head == NULL) {
			stack_insert_after(NULL, f);
		} else {
			stacking_list_t *s = (focused ? limit_above(f) : limit_below(f));
			if (s == NULL) {
				continue;
			}
			int i = stack_cmp(f->client, s->node->client);
			if (i < 0 || (i == 0 && !focused)) {
				stack_insert_before(s, f);
				window_below(f->id, s->node->id);
				put_status(SBSC_MASK_NODE_STACK, "node_stack 0x%08X below 0x%08X\n", f->id, s->node->id);
			} else {
				stack_insert_after(s, f);
				window_above(f->id, s->node->id);
				put_status(SBSC_MASK_NODE_STACK, "node_stack 0x%08X above 0x%08X\n", f->id, s->node->id);
			}
		}
	}

	ewmh_update_client_list(true);
	restack_presel_feedbacks(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbe70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12260
movq -0x20(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x12137
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
cmpl $0x2, 0x308(%rax)
jne 0x1213c
leaq 0x23629(%rip), %rax     # 0x3575b
testb $0x1, (%rax)
jne 0x1213c
jmp 0x1224a
leaq 0x235f5(%rip), %rax     # 0x35738
cmpq $0x0, (%rax)
jne 0x1215b
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x11c00
jmp 0x12248
testb $0x1, -0x11(%rbp)
je 0x12170
movq -0x20(%rbp), %rdi
callq 0x11fa0
movq %rax, -0x38(%rbp)
jmp 0x1217d
movq -0x20(%rbp), %rdi
callq 0x12040
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x12191
jmp 0x1224a
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rsi
callq 0x11f60
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x121be
cmpl $0x0, -0x2c(%rbp)
jne 0x12203
testb $0x1, -0x11(%rbp)
jne 0x12203
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11d50
movq -0x20(%rbp), %rax
movl (%rax), %edi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl (%rax), %esi
callq 0x18760
movq -0x20(%rbp), %rax
movl (%rax), %edx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movl $0x200000, %edi         # imm = 0x200000
leaq 0x1b923(%rip), %rsi     # 0x2db1d
movb $0x0, %al
callq 0x2c0b0
jmp 0x12246
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11c00
movq -0x20(%rbp), %rax
movl (%rax), %edi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl (%rax), %esi
callq 0x16b50
movq -0x20(%rbp), %rax
movl (%rax), %edx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movl $0x200000, %edi         # imm = 0x200000
leaq 0x1b8fe(%rip), %rsi     # 0x2db3d
movb $0x0, %al
callq 0x2c0b0
jmp 0x12248
jmp 0x1224a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xbf80
movq %rax, -0x20(%rbp)
jmp 0x12104
movl $0x1, %edi
callq 0x2b630
movq -0x8(%rbp), %rdi
callq 0x12280
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/stack.c
// Function: restack_presel_feedbacks
void restack_presel_feedbacks(desktop_t *d)
{
	stacking_list_t *s = stack_tail;
	while (s != NULL && !IS_TILED(s->node->client)) {
		s = s->prev;
	}
	if (s != NULL) {
		restack_presel_feedbacks_in(d->root, s->node);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2349d(%rip), %rax     # 0x35730
movq (%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x122df
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rcx
movb $0x1, %al
cmpl $0x0, 0x308(%rcx)
movb %al, -0x12(%rbp)
je 0x122d7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
cmpl $0x1, 0x308(%rax)
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x122e8
jmp 0x122f6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1229a
cmpq $0x0, -0x10(%rbp)
je 0x12311
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x12320
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/stack.c
// Function: restack_presel_feedbacks_in
void restack_presel_feedbacks_in(node_t *r, node_t *n)
{
	if (r == NULL) {
		return;
	} else {
		if (r->presel != NULL) {
			window_above(r->presel->feedback, n->id);
		}
		restack_presel_feedbacks_in(r->first_child, n);
		restack_presel_feedbacks_in(r->second_child, n);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x12339
jmp 0x1237c
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1235a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rax), %edi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x16b50
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x12320
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x12320
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/history.c
// Function: make_history
history_t *make_history(monitor_t *m, desktop_t *d, node_t *n)
{
	history_t *h = calloc(1, sizeof(history_t));
	h->loc = (coordinates_t) {m, d, n};
	h->prev = h->next = NULL;
	h->latest = true;
	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x4890
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/history.c
// Function: history_insert_after
void history_insert_after(history_t *a, history_t *b)
{
	a->next = b->next;
	if (b->next != NULL) {
		b->next->prev = a;
	}
	b->next = a;
	a->prev = b;
	if (history_tail == b) {
		history_tail = a;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x12667
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
leaq 0x2308a(%rip), %rax     # 0x35710
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x1269d
movq -0x8(%rbp), %rcx
leaq 0x23076(%rip), %rax     # 0x35710
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/history.c
// Function: history_insert_before
void history_insert_before(history_t *a, history_t *b)
{
	a->prev = b->prev;
	if (b->prev != NULL) {
		b->prev->next = a;
	}
	b->prev = a;
	a->next = b;
	if (history_head == b) {
		history_head = a;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x126d7
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
leaq 0x23022(%rip), %rax     # 0x35718
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x1270d
movq -0x8(%rbp), %rcx
leaq 0x2300e(%rip), %rax     # 0x35718
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/history.c
// Function: empty_history
void empty_history(void)
{
	history_t *h = history_head;
	while (h != NULL) {
		history_t *next = h->next;
		free(h);
		h = next;
	}
	history_head = history_tail = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x22dd9(%rip), %rax     # 0x35718
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1296c
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4450
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12946
leaq 0x22d9d(%rip), %rax     # 0x35710
movq $0x0, (%rax)
leaq 0x22d97(%rip), %rax     # 0x35718
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/history.c
// Function: history_last_node
node_t *history_last_node(desktop_t *d, node_t *n)
{
	for (history_t *h = history_tail; h != NULL; h = h->prev) {
		if (h->latest && h->loc.node != NULL && !h->loc.node->hidden &&
		    !is_descendant(h->loc.node, n) && h->loc.desktop == d) {
			return h->loc.node;
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x22d69(%rip), %rax     # 0x35710
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12a19
movq -0x20(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x12a09
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x12a09
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
testb $0x1, 0x25(%rax)
jne 0x12a09
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xd040
testb $0x1, %al
jne 0x12a09
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x12a09
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x12a21
jmp 0x12a0b
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x129ae
movq $0x0, -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/history.c
// Function: history_last_desktop
desktop_t *history_last_desktop(monitor_t *m, desktop_t *d)
{
	for (history_t *h = history_tail; h != NULL; h = h->prev) {
		if (h->latest && h->loc.desktop != d && h->loc.monitor == m) {
			return h->loc.desktop;
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x22ccd(%rip), %rax     # 0x35710
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12a94
movq -0x20(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x12a84
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
je 0x12a84
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x12a84
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x12a9c
jmp 0x12a86
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x12a4a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/history.c
// Function: history_last_monitor
monitor_t *history_last_monitor(monitor_t *m)
{
	for (history_t *h = history_tail; h != NULL; h = h->prev) {
		if (h->latest && h->loc.monitor != m) {
			return h->loc.monitor;
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq 0x22c51(%rip), %rax     # 0x35710
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12b01
movq -0x18(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x12af1
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x12af1
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x12b09
jmp 0x12af3
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x12ac6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/history.c
// Function: history_find_newest_node
bool history_find_newest_node(coordinates_t *ref, coordinates_t *dst, node_select_t *sel)
{
	for (history_t *h = history_tail; h != NULL; h = h->prev) {
		if (h->loc.node == NULL ||
		    h->loc.node->hidden ||
		    !node_matches(&h->loc, ref, sel)) {
			continue;
		}
		*dst = h->loc;
		return true;
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x22be5(%rip), %rax     # 0x35710
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x12b9b
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x12b67
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
testb $0x1, 0x25(%rax)
jne 0x12b67
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x23df0
testb $0x1, %al
jne 0x12b69
jmp 0x12b8d
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x12b9f
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x12b32
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)