LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/sxhkd.c
// Function: setup
void setup(void)
{
	int screen_idx;
	dpy = xcb_connect(NULL, &screen_idx);
	if (xcb_connection_has_error(dpy))
		err("Can't open display.\n");
	xcb_screen_t *screen = NULL;
	xcb_screen_iterator_t screen_iter = xcb_setup_roots_iterator(xcb_get_setup(dpy));
	for (; screen_iter.rem; xcb_screen_next(&screen_iter), screen_idx--) {
		if (screen_idx == 0) {
			screen = screen_iter.data;
			break;
		}
	}
	if (screen == NULL)
		err("Can't acquire screen.\n");
	root = screen->root;
	if ((shell = getenv(SXHKD_SHELL_ENV)) == NULL && (shell = getenv(SHELL_ENV)) == NULL)
		err("The '%s' environment variable is not defined.\n", SHELL_ENV);
	symbols = xcb_key_symbols_alloc(dpy);
	hotkeys_head = hotkeys_tail = NULL;
	progress[0] = '\0';

	snprintf(sxhkd_pid, MAXLEN, "%i", getpid());
	setenv("SXHKD_PID", sxhkd_pid, 1);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0xc(%rsp), %rsi
xorl %edi, %edi
callq 0xe100
movq %rax, 0x13a3e(%rip)     # 0x22478
movq %rax, %rdi
callq 0xe310
testl %eax, %eax
jne 0xeb45
movq 0x13a27(%rip), %rdi     # 0x22478
callq 0xe350
movq %rax, %rdi
callq 0xe210
leaq 0x10(%rsp), %rbx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
testl %edx, %edx
je 0xeb37
cmpl $0x0, 0xc(%rsp)
je 0xea8b
movq %rbx, %rdi
callq 0xe1b0
decl 0xc(%rsp)
movl 0x18(%rsp), %edx
jmp 0xea6a
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xeb37
movl (%rax), %eax
movl %eax, 0x139f7(%rip)     # 0x22498
leaq 0x2705(%rip), %rdi      # 0x111ad
callq 0xe030
movq %rax, 0x139ec(%rip)     # 0x224a0
testq %rax, %rax
jne 0xead1
leaq 0x26f3(%rip), %rdi      # 0x111b3
callq 0xe030
movq %rax, 0x139d4(%rip)     # 0x224a0
testq %rax, %rax
je 0xeb4e
movq 0x139a0(%rip), %rdi     # 0x22478
callq 0xe110
movq %rax, 0x139a4(%rip)     # 0x22488
andq $0x0, 0x139bc(%rip)     # 0x224a8
andq $0x0, 0x139bc(%rip)     # 0x224b0
movb $0x0, 0x139c5(%rip)     # 0x224c0
callq 0xe0c0
leaq 0x13cb9(%rip), %rbx     # 0x227c0
leaq 0x258e(%rip), %rdx      # 0x1109c
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0xe170
leaq 0x26c2(%rip), %rdi      # 0x111e8
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0xe0b0
addq $0x20, %rsp
popq %rbx
retq
leaq 0x2658(%rip), %rdi      # 0x11196
xorl %eax, %eax
callq 0xf1f8
leaq 0x2635(%rip), %rdi      # 0x11181
jmp 0xeb3e
leaq 0x2664(%rip), %rdi      # 0x111b9
leaq 0x2657(%rip), %rsi      # 0x111b3
xorl %eax, %eax
callq 0xf1f8
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/sxhkd.c
// Function: key_button_event
void key_button_event(xcb_generic_event_t *evt, uint8_t event_type)
{
	xcb_keysym_t keysym = XCB_NO_SYMBOL;
	xcb_button_t button = XCB_NONE;
	bool replay_event = false;
	uint16_t modfield = 0;
	uint16_t lockfield = num_lock | caps_lock | scroll_lock;
	parse_event(evt, event_type, &keysym, &button, &modfield);
	modfield &= ~lockfield & MOD_STATE_FIELD;
	if (keysym != XCB_NO_SYMBOL || button != XCB_NONE) {
		hotkey_t *hk = find_hotkey(keysym, button, modfield, event_type, &replay_event);
		if (hk != NULL) {
			run(hk->command, hk->sync);
			put_status(COMMAND_PREFIX, hk->command);
		}
	}
	switch (event_type) {
		case XCB_BUTTON_PRESS:
		case XCB_BUTTON_RELEASE:
			if (replay_event)
				xcb_allow_events(dpy, XCB_ALLOW_REPLAY_POINTER, XCB_CURRENT_TIME);
			else
				xcb_allow_events(dpy, XCB_ALLOW_SYNC_POINTER, XCB_CURRENT_TIME);
			break;
		case XCB_KEY_PRESS:
		case XCB_KEY_RELEASE:
			if (replay_event)
				xcb_allow_events(dpy, XCB_ALLOW_REPLAY_KEYBOARD, XCB_CURRENT_TIME);
			else
				xcb_allow_events(dpy, XCB_ALLOW_SYNC_KEYBOARD, XCB_CURRENT_TIME);
			break;
	}
	xcb_flush(dpy);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %r14
andl $0x0, (%r14)
movl %esi, %ebx
xorl %eax, %eax
leaq 0x9(%rsp), %r15
leaq 0xa(%rsp), %r12
andw $0x0, (%r12)
movb %al, (%r15)
movb %al, 0x8(%rsp)
movzbl 0x138f6(%rip), %eax     # 0x22490
movzbl 0x138f1(%rip), %ecx     # 0x22492
orl %eax, %ecx
movzbl 0x138ea(%rip), %ebp     # 0x22494
orl %ecx, %ebp
notl %ebp
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0xf81e
movzbl (%r12), %eax
andl %ebp, %eax
movw %ax, (%r12)
movl (%r14), %edi
testl %edi, %edi
setne %dl
movb (%r15), %cl
testb %cl, %cl
setne %sil
orb %dl, %sil
movzbl %bl, %ebx
cmpb $0x1, %sil
jne 0xec1d
movzbl %cl, %esi
movzwl %ax, %edx
leaq 0x8(%rsp), %r8
movl %ebx, %ecx
callq 0x1059c
testq %rax, %rax
je 0xec1d
movq %rax, %r14
addq $0x8, %r14
movzbl 0x208(%rax), %esi
movq %r14, %rdi
callq 0xf290
pushq $0x43
popq %rdi
movq %r14, %rsi
callq 0xed3a
leal -0x2(%rbx), %eax
cmpl $0x2, %eax
jb 0xec3f
addl $-0x4, %ebx
cmpl $0x1, %ebx
ja 0xec5f
movq 0x13844(%rip), %rdi     # 0x22478
cmpb $0x1, 0x8(%rsp)
jne 0xec51
pushq $0x2
jmp 0xec57
movq 0x13832(%rip), %rdi     # 0x22478
cmpb $0x1, 0x8(%rsp)
jne 0xec55
pushq $0x5
jmp 0xec57
pushq $0x1
jmp 0xec57
pushq $0x4
popq %rsi
xorl %edx, %edx
callq 0xe120
movq 0x13812(%rip), %rdi     # 0x22478
callq 0xe140
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/sxhkd.c
// Function: mapping_notify
void mapping_notify(xcb_generic_event_t *evt)
{
	if (!mapping_count)
		return;
	xcb_mapping_notify_event_t *e = (xcb_mapping_notify_event_t *) evt;
	PRINTF("mapping notify %u %u\n", e->request, e->count);
	if (e->request == XCB_MAPPING_POINTER)
		return;
	if (xcb_refresh_keyboard_mapping(symbols, e) == 1) {
		destroy_chord(abort_chord);
		get_lock_fields();
		reload_cmd();
		abort_chord = make_chord(abort_keysym, XCB_NONE, 0, XCB_KEY_PRESS, false, false);
		if (mapping_count > 0)
			mapping_count--;
	}
}

// Assembly:
cmpl $0x0, 0x136d1(%rip)     # 0x22350
je 0xece7
movq %rdi, %rsi
cmpb $0x2, 0x4(%rdi)
je 0xece7
pushq %rax
movq 0x137f6(%rip), %rdi     # 0x22488
callq 0xe050
cmpl $0x1, %eax
jne 0xece3
movq 0x137cd(%rip), %rdi     # 0x22470
callq 0x10cdd
callq 0x104a3
callq 0xece8
movl 0x136a8(%rip), %edi     # 0x22360
pushq $0x2
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x109d8
movq %rax, 0x1379f(%rip)     # 0x22470
movl 0x13679(%rip), %eax     # 0x22350
testl %eax, %eax
jle 0xece3
decl %eax
movl %eax, 0x1366d(%rip)     # 0x22350
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/sxhkd.c
// Function: reload_cmd
void reload_cmd(void)
{
	PUTS("reload");
	cleanup();
	load_config(config_file);
	for (int i = 0; i < num_extra_confs; i++)
		load_config(extra_confs[i]);
	ungrab();
	grab();
}

// Assembly:
pushq %rbx
callq 0xed6b
leaq 0x1367b(%rip), %rdi     # 0x22370
callq 0xf3fc
xorl %ebx, %ebx
movslq 0x13661(%rip), %rax     # 0x22364
cmpq %rax, %rbx
jge 0xed1d
movq 0x13659(%rip), %rax     # 0x22368
movq (%rax,%rbx,8), %rdi
callq 0xf3fc
incq %rbx
jmp 0xecfc
callq 0xf10d
popq %rbx
jmp 0xedbc
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/sxhkd.c
// Function: cleanup
void cleanup(void)
{
	PUTS("cleanup");
	hotkey_t *hk = hotkeys_head;
	while (hk != NULL) {
		hotkey_t *next = hk->next;
		destroy_chain(hk->chain);
		free(hk->cycle);
		free(hk);
		hk = next;
	}
	hotkeys_head = hotkeys_tail = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x1373a(%rip), %rbx     # 0x224b0
testq %rbx, %rbx
je 0xeda3
movq 0x218(%rbx), %r14
movq (%rbx), %rdi
callq 0x10cae
movq 0x210(%rbx), %rdi
callq 0xe040
movq %rbx, %rdi
callq 0xe040
movq %r14, %rbx
jmp 0xed76
andq $0x0, 0x136fd(%rip)     # 0x224a8
andq $0x0, 0x136fd(%rip)     # 0x224b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/grab.c
// Function: grab
void grab(void)
{
	PUTS("grab");
	for (hotkey_t *hk = hotkeys_head; hk != NULL; hk = hk->next)
		grab_chord(hk->chain->head);
	xcb_flush(dpy);
	grabbed = true;
}

// Assembly:
pushq %rbx
leaq 0x136ec(%rip), %rbx     # 0x224b0
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xede0
movq (%rbx), %rax
movq (%rax), %rdi
callq 0xedfb
addq $0x218, %rbx            # imm = 0x218
jmp 0xedc4
leaq 0x13691(%rip), %rax     # 0x22478
movq (%rax), %rdi
callq 0xe140
leaq 0x13562(%rip), %rax     # 0x22358
movb $0x1, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/grab.c
// Function: grab_chord
void grab_chord(chord_t *chord)
{
	for (chord_t *c = chord; c != NULL; c = c->more) {
		if (c->button == XCB_NONE) {
			xcb_keycode_t *keycodes = keycodes_from_keysym(c->keysym);
			if (keycodes != NULL)
				for (xcb_keycode_t *kc = keycodes; *kc != XCB_NO_SYMBOL; kc++)
					if (c->keysym == xcb_key_symbols_get_keysym(symbols, *kc, 0))
						grab_key_button(*kc, c->button, c->modfield);
			free(keycodes);
		} else {
			grab_key_button(XCB_NONE, c->button, c->modfield);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x1367b(%rip), %r15     # 0x22488
testq %rbx, %rbx
je 0xee99
movb 0x104(%rbx), %al
testb %al, %al
je 0xee33
movzwl 0x106(%rbx), %edx
movzbl %al, %esi
xorl %edi, %edi
callq 0xeea2
jmp 0xee8d
movl 0x100(%rbx), %edi
callq 0x104dc
movq %rax, %r14
testq %rax, %rax
je 0xee85
movq %r14, %r12
movb (%r12), %al
testb %al, %al
je 0xee85
movl 0x100(%rbx), %ebp
movq (%r15), %rdi
movzbl %al, %esi
xorl %edx, %edx
callq 0xe250
cmpl %eax, %ebp
jne 0xee80
movzbl (%r12), %edi
movzbl 0x104(%rbx), %esi
movzwl 0x106(%rbx), %edx
callq 0xeea2
incq %r12
jmp 0xee49
movq %r14, %rdi
callq 0xe040
movq 0x118(%rbx), %rbx
jmp 0xee0d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/grab.c
// Function: grab_key_button
void grab_key_button(xcb_keycode_t keycode, xcb_button_t button, uint16_t modfield)
{
	grab_key_button_checked(keycode, button, modfield);
	if (modfield == XCB_MOD_MASK_ANY)
		return;
	if (num_lock != 0)
		grab_key_button_checked(keycode, button, modfield | num_lock);
	if (caps_lock != 0)
		grab_key_button_checked(keycode, button, modfield | caps_lock);
	if (scroll_lock != 0)
		grab_key_button_checked(keycode, button, modfield | scroll_lock);
	if (num_lock != 0 && caps_lock != 0)
		grab_key_button_checked(keycode, button, modfield | num_lock | caps_lock);
	if (caps_lock != 0 && scroll_lock != 0)
		grab_key_button_checked(keycode, button, modfield | caps_lock | scroll_lock);
	if (num_lock != 0 && scroll_lock != 0)
		grab_key_button_checked(keycode, button, modfield | num_lock | scroll_lock);
	if (num_lock != 0 && caps_lock != 0 && scroll_lock != 0)
		grab_key_button_checked(keycode, button, modfield | num_lock | caps_lock | scroll_lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %ebp
callq 0xf01c
cmpl $0x8000, %ebx           # imm = 0x8000
je 0xf00d
leaq 0x135c4(%rip), %r15     # 0x22490
movzwl (%r15), %eax
movzbl %bpl, %ebp
movzbl %r14b, %r14d
testw %ax, %ax
je 0xeeec
orl %ebx, %eax
movzwl %ax, %edx
movl %ebp, %edi
movl %r14d, %esi
callq 0xf01c
leaq 0x1359f(%rip), %r12     # 0x22492
movzwl (%r12), %eax
testw %ax, %ax
je 0xef0c
orl %ebx, %eax
movzwl %ax, %edx
movl %ebp, %edi
movl %r14d, %esi
callq 0xf01c
leaq 0x13581(%rip), %r13     # 0x22494
movzwl (%r13), %eax
testw %ax, %ax
je 0xef2c
orl %ebx, %eax
movzwl %ax, %edx
movl %ebp, %edi
movl %r14d, %esi
callq 0xf01c
movzwl (%r15), %eax
testw %ax, %ax
setne %dl
movzwl (%r12), %ecx
testw %cx, %cx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0xef61
orl %ebx, %eax
orl %eax, %ecx
movzwl %cx, %edx
movl %ebp, %edi
movl %r14d, %esi
callq 0xf01c
movzwl (%r12), %ecx
testw %cx, %cx
setne %dl
movzwl (%r13), %eax
testw %ax, %ax
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0xef92
orl %ebx, %ecx
orl %ecx, %eax
movzwl %ax, %edx
movl %ebp, %edi
movl %r14d, %esi
callq 0xf01c
movzwl (%r13), %eax
movzwl (%r15), %ecx
testw %cx, %cx
setne %dl
testw %ax, %ax
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0xefc6
orl %ebx, %ecx
orl %ecx, %eax
movzwl %ax, %edx
movl %ebp, %edi
movl %r14d, %esi
callq 0xf01c
movzwl (%r15), %ecx
movzwl (%r13), %eax
testw %cx, %cx
setne %sil
movzwl (%r12), %edx
testw %dx, %dx
setne %dil
andb %sil, %dil
testw %ax, %ax
setne %sil
andb %dil, %sil
cmpb $0x1, %sil
jne 0xf00d
orl %ebx, %ecx
orl %edx, %eax
orl %ecx, %eax
movzwl %ax, %edx
movl %ebp, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf01c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/grab.c
// Function: grab_key_button_checked
void grab_key_button_checked(xcb_keycode_t keycode, xcb_button_t button, uint16_t modfield)
{
	xcb_generic_error_t *err;
	if (button == XCB_NONE)
		err = xcb_request_check(dpy, xcb_grab_key_checked(dpy, true, root, modfield, keycode, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_SYNC));
	else
		err = xcb_request_check(dpy, xcb_grab_button_checked(dpy, true, root, XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE, XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC, XCB_NONE, XCB_NONE, button, modfield));
	unsigned int value = (button == XCB_NONE ? keycode : button);
	char *type = (button == XCB_NONE ? "key" : "button");
	if (err != NULL) {
		warn("Could not grab %s %u with modfield %u: ", type, value, modfield);
		if (err->error_code == XCB_ACCESS)
			warn("the combination is already grabbed.\n");
		else
			warn("error %u encountered.\n", err->error_code);
		free(err);
	} else {
		PRINTF("grab %s %u %u\n", type, value, modfield);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %eax
leaq 0x13449(%rip), %rcx     # 0x22478
movq (%rcx), %r14
leaq 0x1345f(%rip), %rcx     # 0x22498
movl (%rcx), %edx
movzbl %sil, %r15d
movzwl %ax, %ebx
movzbl %dil, %ebp
testl %esi, %esi
je 0xf072
movl %ebx, 0x18(%rsp)
andl $0x0, 0x8(%rsp)
movl %r15d, 0x10(%rsp)
andl $0x0, (%rsp)
pushq $0xc
popq %rcx
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %r8d, %r8d
movl %esi, %r9d
callq 0xe3b0
jmp 0xf089
andl $0x0, (%rsp)
pushq $0x1
popq %rsi
movq %r14, %rdi
movl %ebx, %ecx
movl %ebp, %r8d
movl %esi, %r9d
callq 0xe0a0
movq %r14, %rdi
movl %eax, %esi
callq 0xe2a0
testq %rax, %rax
je 0xf0e2
movq %rax, %r14
testb %r15b, %r15b
leaq 0x229d(%rip), %rax      # 0x11342
leaq 0x21bd(%rip), %rsi      # 0x11269
cmoveq %rax, %rsi
cmovnel %r15d, %ebp
movzbl %bpl, %edx
leaq 0x21b1(%rip), %rdi      # 0x11270
movl %ebx, %ecx
xorl %eax, %eax
callq 0xf160
movzbl 0x1(%r14), %esi
cmpl $0xa, %esi
jne 0xf0ed
leaq 0x21bf(%rip), %rdi      # 0x11298
xorl %eax, %eax
callq 0xf160
jmp 0xf0fb
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21c9(%rip), %rdi      # 0x112bd
xorl %eax, %eax
callq 0xf160
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe040
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/grab.c
// Function: ungrab
void ungrab(void)
{
	PUTS("ungrab");
	xcb_ungrab_key(dpy, XCB_GRAB_ANY, root, XCB_BUTTON_MASK_ANY);
	xcb_ungrab_button(dpy, XCB_BUTTON_INDEX_ANY, root, XCB_MOD_MASK_ANY);
	xcb_flush(dpy);
	grabbed = false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x13360(%rip), %rbx     # 0x22478
movq (%rbx), %rdi
leaq 0x13376(%rip), %r14     # 0x22498
movl (%r14), %edx
xorl %esi, %esi
movl $0x8000, %ecx           # imm = 0x8000
callq 0xe390
movq (%rbx), %rdi
movl (%r14), %edx
xorl %esi, %esi
movl $0x8000, %ecx           # imm = 0x8000
callq 0xe2f0
movq (%rbx), %rdi
callq 0xe140
leaq 0x13206(%rip), %rax     # 0x22358
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/helpers.c
// Function: spawn
void spawn(char *cmd[], bool sync)
{
	if (fork() == 0) {
		if (dpy != NULL)
			close(xcb_get_file_descriptor(dpy));
		if (sync) {
			execute(cmd);
		} else {
			if (fork() == 0) {
				execute(cmd);
			}
			exit(EXIT_SUCCESS);
		}
	}
	wait(NULL);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xe3e0
testl %eax, %eax
je 0xf2e3
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe3c0
leaq 0x1318e(%rip), %rax     # 0x22478
movq (%rax), %rdi
testq %rdi, %rdi
je 0xf2fe
callq 0xe060
movl %eax, %edi
callq 0xe1d0
testb %bpl, %bpl
jne 0xf30c
callq 0xe3e0
testl %eax, %eax
jne 0xf314
movq %rbx, %rdi
callq 0xf31b
xorl %edi, %edi
callq 0xe3a0
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/helpers.c
// Function: execute
void execute(char *cmd[])
{
	setsid();
	if (redir_fd != -1) {
		dup2(redir_fd, STDOUT_FILENO);
		dup2(redir_fd, STDERR_FILENO);
	}
	execvp(cmd[0], cmd);
	err("Spawning failed.\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xe1e0
leaq 0x1302e(%rip), %r14     # 0x2235c
movl (%r14), %edi
cmpl $-0x1, %edi
je 0xf349
pushq $0x1
popq %rsi
callq 0xe150
movl (%r14), %edi
pushq $0x2
popq %rsi
callq 0xe150
movq (%rbx), %rdi
movq %rbx, %rsi
callq 0xe360
leaq 0x1f7c(%rip), %rdi      # 0x112d7
xorl %eax, %eax
callq 0xf1f8
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/helpers.c
// Function: lgraph
char *lgraph(char *s)
{
	size_t len = strlen(s);
	unsigned int i = 0;
	while (i < len && !isgraph(s[i]))
		i++;
	if (i < len)
		return (s + i);
	else
		return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xe130
movq %rax, %r15
xorl %r14d, %r14d
xorl %eax, %eax
movl %eax, %r12d
cmpq %r12, %r15
jbe 0xf3a1
callq 0xe3f0
movq (%rax), %rcx
movsbq (%rbx,%r12), %rdx
leal 0x1(%r12), %eax
cmpw $0x0, (%rcx,%rdx,2)
jns 0xf37a
addq %r12, %rbx
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/parse.c
// Function: load_config
void load_config(const char *config_file)
{
	PRINTF("load configuration '%s'\n", config_file);
	FILE *cfg = fopen(config_file, "r");
	if (cfg == NULL)
		err("Can't open configuration file: '%s'.\n", config_file);

	char buf[3 * MAXLEN];
	char chain[MAXLEN] = {0};
	char command[2 * MAXLEN] = {0};
	int offset = 0;
	char first;

	while (fgets(buf, sizeof(buf), cfg) != NULL) {
		first = buf[0];
		if (strlen(buf) < 2 || first == START_COMMENT) {
			continue;
		} else {
			char *start = lgraph(buf);
			if (start == NULL)
				continue;
			char *end = rgraph(buf);
			*(end + 1) = '\0';

			if (isgraph(first))
				snprintf(chain + offset, sizeof(chain) - offset, "%s", start);
			else
				snprintf(command + offset, sizeof(command) - offset, "%s", start);

			if (*end == PARTIAL_LINE) {
				offset += end - start;
				continue;
			} else {
				offset = 0;
			}

			if (isspace(first) && strlen(chain) > 0 && strlen(command) > 0) {
				process_hotkey(chain, command);
				chain[0] = '\0';
				command[0] = '\0';
			}
		}
	}

	fclose(cfg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x628, %rsp            # imm = 0x628
movq %rdi, %r14
leaq 0x3a6d(%rip), %rsi      # 0x12e84
callq 0xe330
testq %rax, %rax
je 0xf58f
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0xe190
leaq 0x120(%rsp), %r15
movl $0x200, %edx            # imm = 0x200
movq %r15, %rdi
xorl %esi, %esi
callq 0xe190
leaq 0x320(%rsp), %r12
xorl %r13d, %r13d
movq %r12, %rdi
movl $0x300, %esi            # imm = 0x300
movq %rbx, %rdx
callq 0xe1f0
testq %rax, %rax
je 0xf575
movb 0x320(%rsp), %r14b
movq %r12, %rdi
callq 0xe130
cmpq $0x2, %rax
setb %al
cmpb $0x23, %r14b
sete %cl
orb %al, %cl
jne 0xf45b
movq %r12, %rdi
callq 0xf362
testq %rax, %rax
je 0xf45b
movq %rax, %rbp
movsbq %r14b, %r14
movq %r12, %rdi
callq 0xf3b0
movq %rax, 0x18(%rsp)
movb $0x0, 0x1(%rax)
callq 0xe3f0
movq %rax, 0x8(%rsp)
movq (%rax), %rax
xorl %esi, %esi
movq %r14, 0x10(%rsp)
cmpw $0x0, (%rax,%r14,2)
setns %sil
movslq %r13d, %rax
leaq 0x20(%rsp), %rdi
cmovnsq %r15, %rdi
shll $0x8, %esi
addq %rax, %rdi
subq %rax, %rsi
addq $0x100, %rsi            # imm = 0x100
leaq 0x1c2b(%rip), %rdx      # 0x11127
movq %rbp, %rcx
xorl %eax, %eax
callq 0xe170
movq 0x18(%rsp), %r14
cmpb $0x5c, (%r14)
jne 0xf51c
subl %ebp, %r14d
addl %r14d, %r13d
jmp 0xf45b
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
movl $0x0, %r13d
je 0xf45b
cmpb $0x0, 0x20(%rsp)
je 0xf45b
cmpb $0x0, 0x120(%rsp)
je 0xf45b
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0xf5a0
xorl %r13d, %r13d
movb %r13b, 0x20(%rsp)
movb %r13b, 0x120(%rsp)
jmp 0xf45b
movq %rbx, %rdi
callq 0xe0f0
addq $0x628, %rsp            # imm = 0x628
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7d55(%rip), %rdi      # 0x172eb
movq %r14, %rsi
xorl %eax, %eax
callq 0xf1f8
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/parse.c
// Function: parse_event
void parse_event(xcb_generic_event_t *evt, uint8_t event_type, xcb_keysym_t *keysym, xcb_button_t *button, uint16_t *modfield)
{
	if (event_type == XCB_KEY_PRESS) {
		xcb_key_press_event_t *e = (xcb_key_press_event_t *) evt;
		xcb_keycode_t keycode = e->detail;
		*modfield = e->state;
		*keysym = xcb_key_symbols_get_keysym(symbols, keycode, 0);
		PRINTF("key press %u %u\n", keycode, *modfield);
	} else if (event_type == XCB_KEY_RELEASE) {
		xcb_key_release_event_t *e = (xcb_key_release_event_t *) evt;
		xcb_keycode_t keycode = e->detail;
		*modfield = e->state & ~modfield_from_keycode(keycode);
		*keysym = xcb_key_symbols_get_keysym(symbols, keycode, 0);
		PRINTF("key release %u %u\n", keycode, *modfield);
	} else if (event_type == XCB_BUTTON_PRESS) {
		xcb_button_press_event_t *e = (xcb_button_press_event_t *) evt;
		*button = e->detail;
		*modfield = e->state;
		PRINTF("button press %u %u\n", *button, *modfield);
	} else if (event_type == XCB_BUTTON_RELEASE) {
		xcb_button_release_event_t *e = (xcb_button_release_event_t *) evt;
		*button = e->detail;
		*modfield = e->state;
		PRINTF("button release %u %u\n", *button, *modfield);
	}
}

// Assembly:
addl $-0x2, %esi
cmpl $0x3, %esi
ja 0xf8a3
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rdx, %rbx
leaq 0x1ab2(%rip), %rax      # 0x112ec
movslq (%rax,%rsi,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movb 0x1(%rdi), %al
movb %al, (%rcx)
movzwl 0x1c(%rdi), %eax
movw %ax, (%r14)
jmp 0xf899
movzbl 0x1(%rdi), %esi
movzwl 0x1c(%rdi), %eax
movw %ax, (%r14)
leaq 0x12c23(%rip), %rax     # 0x22488
movq (%rax), %rdi
jmp 0xf890
movzbl 0x1(%rdi), %ebp
movzwl 0x1c(%rdi), %r15d
movl %ebp, %edi
callq 0xf8a4
notl %eax
andw %r15w, %ax
movw %ax, (%r14)
leaq 0x12bfd(%rip), %rax     # 0x22488
movq (%rax), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xe250
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/parse.c
// Function: modfield_from_keycode
int16_t modfield_from_keycode(xcb_keycode_t keycode)
{
	uint16_t modfield = 0;
	xcb_keycode_t *mod_keycodes = NULL;
	xcb_get_modifier_mapping_reply_t *reply = NULL;
	if ((reply = xcb_get_modifier_mapping_reply(dpy, xcb_get_modifier_mapping(dpy), NULL)) != NULL && reply->keycodes_per_modifier > 0) {
		if ((mod_keycodes = xcb_get_modifier_mapping_keycodes(reply)) != NULL) {
			unsigned int num_mod = xcb_get_modifier_mapping_keycodes_length(reply) / reply->keycodes_per_modifier;
			for (unsigned int i = 0; i < num_mod; i++) {
				for (unsigned int j = 0; j < reply->keycodes_per_modifier; j++) {
					xcb_keycode_t mkc = mod_keycodes[i * reply->keycodes_per_modifier + j];
					if (mkc == XCB_NO_SYMBOL)
						continue;
					if (keycode == mkc)
						modfield |= (1 << i);
				}
			}

		}
	}
	free(reply);
	return modfield;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebp
leaq 0x12bc0(%rip), %rax     # 0x22478
movq (%rax), %rbx
movq %rbx, %rdi
callq 0xe0d0
xorl %r14d, %r14d
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0xe3d0
movq %rax, %rbx
testq %rax, %rax
je 0xf94c
cmpb $0x0, 0x1(%rbx)
je 0xf949
movq %rbx, %rdi
callq 0xe080
xorl %r12d, %r12d
testq %rax, %rax
je 0xf949
movq %rax, %r15
movq %rbx, %rdi
callq 0xe0e0
movzbl 0x1(%rbx), %esi
cltd
idivl %esi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
xorl %r14d, %r14d
cmpl %eax, %ecx
je 0xf94c
movl %edx, %edi
shll %cl, %edi
movl %r12d, %r8d
movq %rsi, %r9
subq $0x1, %r9
jb 0xf942
movl %r8d, %r10d
movb (%r15,%r10), %r13b
xorl %r10d, %r10d
movl %edi, %r11d
cmpb %bpl, %r13b
je 0xf933
xorl %r11d, %r11d
testb %r13b, %r13b
cmovel %r10d, %r11d
orl %r11d, %r14d
incl %r8d
jmp 0xf918
incl %ecx
addl %esi, %r12d
jmp 0xf90a
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0xe040
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/parse.c
// Function: extract_chunks
chunk_t *extract_chunks(char *s)
{
	size_t len = strlen(s);
	unsigned int i = 0, j = 0;
	bool inhibit = false;
	int num_seq = 0;
	chunk_t *c = make_chunk();
	chunk_t *head = c;
	while (i < len) {
		if (inhibit) {
			c->text[j++] = s[i];
			inhibit = false;
		} else if (s[i] == MAGIC_INHIBIT) {
			inhibit = true;
			if ((s[i+1] != MAGIC_INHIBIT || c->sequence)
					&& s[i+1] != SEQ_BEGIN
					&& s[i+1] != SEQ_END)
				c->text[j++] = s[i];
		} else if (s[i] == SEQ_BEGIN) {
			if (j > 0) {
				c->text[j] = '\0';
				j = 0;
				chunk_t *next = make_chunk();
				c->next = next;
				c = next;
			}
			c->sequence = true;
		} else if (s[i] == SEQ_END) {
			if (c->sequence)
				num_seq++;
			if (j > 0) {
				c->text[j] = '\0';
				j = 0;
				chunk_t *next = make_chunk();
				c->next = next;
				c = next;
			}
			c->sequence = false;
		} else {
			c->text[j++] = s[i];
		}
		i++;
	}
	c->text[j] = '\0';
	return head;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xe130
movq %rax, %r14
xorl %ebp, %ebp
pushq $0x1
popq %r12
callq 0xffc7
movq %rax, %r15
movq %rax, %r13
xorl %eax, %eax
leal -0x1(%r12), %edx
movl %eax, %ecx
cmpq %rdx, %r14
jbe 0xfa45
movb (%rbx,%rdx), %dl
testb $0x1, %bpl
je 0xf9b6
incl %eax
movb %dl, (%r13,%rcx)
xorl %ebp, %ebp
jmp 0xfa3d
movzbl %dl, %esi
cmpl $0x7d, %esi
je 0xfa18
cmpl $0x7b, %esi
je 0xf9f5
cmpl $0x5c, %esi
jne 0xf9a8
movl %r12d, %edx
movzbl (%rbx,%rdx), %edx
movb $0x1, %bpl
cmpl $0x7d, %edx
je 0xfa3d
cmpl $0x7b, %edx
je 0xfa3d
cmpl $0x5c, %edx
jne 0xf9eb
cmpb $0x1, 0x408(%r13)
jne 0xfa3d
incl %eax
movb $0x5c, (%r13,%rcx)
jmp 0xfa3d
testl %eax, %eax
je 0xfa0e
movb $0x0, (%r13,%rcx)
callq 0xffc7
movq %rax, 0x410(%r13)
movq %rax, %r13
movb $0x1, 0x408(%r13)
jmp 0xfa39
testl %eax, %eax
je 0xfa31
movb $0x0, (%r13,%rcx)
callq 0xffc7
movq %rax, 0x410(%r13)
movq %rax, %r13
movb $0x0, 0x408(%r13)
xorl %ebp, %ebp
xorl %eax, %eax
incl %r12d
jmp 0xf98f
movb $0x0, (%r13,%rcx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/parse.c
// Function: destroy_chunks
void destroy_chunks(chunk_t *chunk)
{
	chunk_t *c = chunk;
	while (c != NULL) {
		chunk_t *next = c->next;
		free(c);
		c = next;
	}
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xfa74
movq 0x410(%rdi), %rbx
callq 0xe040
movq %rbx, %rdi
jmp 0xfa5e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/parse.c
// Function: get_token
char *get_token(char *dst, char *ign, char *src, char *sep)
{
	size_t len = strlen(src);
	unsigned int i = 0, j = 0, k = 0;
	bool inhibit = false;
	bool found = false;
	while (i < len && !found) {
		if (inhibit) {
			dst[j++] = src[i];
			inhibit = false;
		} else if (src[i] == MAGIC_INHIBIT) {
			inhibit = true;
			if (src[i+1] != MAGIC_INHIBIT && strchr(sep, src[i+1]) == NULL)
				dst[j++] = src[i];
		} else if (strchr(sep, src[i]) != NULL) {
			if (j > 0)
				found = true;
			do {
				if (ign != NULL)
					ign[k++] = src[i];
				i++;
			} while (i < len && strchr(sep, src[i]) != NULL);
			i--;
		} else {
			dst[j++] = src[i];
		}
		i++;
	}
	dst[j] = '\0';
	if (ign != NULL)
		ign[k] = '\0';
	return src + i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x18(%rsp)
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdx, %rdi
callq 0xe130
movq %rax, %r13
xorl %r15d, %r15d
movl $0x0, 0x8(%rsp)
xorl %ebp, %ebp
xorl %ecx, %ecx
xorl %eax, %eax
movl %r15d, %edx
movl 0x8(%rsp), %r12d
cmpq %rdx, %r13
jbe 0xff9a
testb $0x1, %al
jne 0xff9a
movq 0x10(%rsp), %rax
movb (%rax,%rdx), %bl
testb $0x1, %cl
je 0xff03
xorl %ecx, %ecx
incl 0x8(%rsp)
movq 0x20(%rsp), %rax
movb %bl, (%rax,%r12)
xorl %eax, %eax
incl %r15d
jmp 0xfec7
cmpb $0x5c, %bl
jne 0xff20
leal 0x1(%r15), %eax
movq 0x10(%rsp), %rcx
movsbl (%rcx,%rax), %esi
cmpl $0x5c, %esi
jne 0xff7e
xorl %eax, %eax
movb $0x1, %cl
jmp 0xfefe
movsbl %bl, %esi
movq 0x18(%rsp), %rdi
callq 0xe160
testq %rax, %rax
je 0xfeed
cmpl $0x0, 0x8(%rsp)
setne %al
movl %eax, 0xc(%rsp)
movl %r15d, %r12d
testq %r14, %r14
je 0xff4e
movl %ebp, %eax
incl %ebp
movb %bl, (%r14,%rax)
leal 0x1(%r12), %r15d
cmpq %r15, %r13
jbe 0xff73
movq 0x10(%rsp), %rax
movb (%rax,%r15), %bl
movsbl %bl, %esi
movq 0x18(%rsp), %rdi
callq 0xe160
testq %rax, %rax
jne 0xff3e
xorl %ecx, %ecx
movl %r12d, %r15d
movl 0xc(%rsp), %eax
jmp 0xfefe
movq 0x18(%rsp), %rdi
callq 0xe160
movb $0x1, %cl
testq %rax, %rax
jne 0xfefc
movb $0x5c, %bl
jmp 0xfeef
movq 0x20(%rsp), %rax
movb $0x0, (%rax,%r12)
testq %r14, %r14
je 0xffb0
movl %ebp, %ecx
movb $0x0, (%r14,%rcx)
movq 0x10(%rsp), %rax
addq %rdx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/parse.c
// Function: parse_keysym
bool parse_keysym(char *name, xcb_keysym_t *keysym)
{
	for (unsigned int i = 0; i < LENGTH(nks_dict); i++) {
		keysym_dict_t nks = nks_dict[i];
		if (strcmp(name, nks.name) == 0) {
			*keysym = nks.keysym;
			return true;
		}
	}
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9ffa(%rip), %r15      # 0x1a210
xorl %ecx, %ecx
movq %rcx, %r12
cmpq $0x812, %rcx            # imm = 0x812
je 0x10242
movq (%r15), %rsi
movq %r14, %rdi
callq 0xe220
leaq 0x1(%r12), %rcx
addq $0x10, %r15
testl %eax, %eax
jne 0x10218
movl -0x8(%r15), %eax
movl %eax, (%rbx)
cmpq $0x812, %r12            # imm = 0x812
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/parse.c
// Function: modfield_from_keysym
int16_t modfield_from_keysym(xcb_keysym_t keysym)
{
	uint16_t modfield = 0;
	xcb_keycode_t *keycodes = NULL;
	if ((keycodes = keycodes_from_keysym(keysym)) != NULL) {
		for (xcb_keycode_t *k = keycodes; *k != XCB_NO_SYMBOL; k++)
			modfield |= modfield_from_keycode(*k);
	}
	free(keycodes);
	return modfield;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x104dc
movq %rax, %rbx
xorl %ebp, %ebp
testq %rax, %rax
je 0x102b0
movq %rbx, %r14
movb (%r14), %al
testb %al, %al
je 0x102b0
movzbl %al, %edi
callq 0xf8a4
orl %eax, %ebp
incq %r14
jmp 0x1029a
movq %rbx, %rdi
callq 0xe040
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/parse.c
// Function: get_standard_keysyms
void get_standard_keysyms(void)
{
#define GETKS(X) \
	if (!parse_keysym(#X, &X)) \
		warn("Couldn't retrieve keysym for '%s'.\n", #X); \
	else \
		PRINTF("keysym for '%s' is 0x%X.\n", #X, X);
	GETKS(Alt_L)
	GETKS(Alt_R)
	GETKS(Super_L)
	GETKS(Super_R)
	GETKS(Hyper_L)
	GETKS(Hyper_R)
	GETKS(Mode_switch)
	GETKS(Num_Lock)
	GETKS(Scroll_Lock)
#undef GETKS
}

// Assembly:
pushq %rax
leaq 0x1364(%rip), %rdi      # 0x1167f
leaq 0x1259e(%rip), %rsi     # 0x228c0
callq 0x10201
testb %al, %al
jne 0x10340
leaq 0x70af(%rip), %rdi      # 0x173e1
leaq 0x1346(%rip), %rsi      # 0x1167f
xorl %eax, %eax
callq 0xf160
leaq 0x133e(%rip), %rdi      # 0x11685
leaq 0x12576(%rip), %rsi     # 0x228c4
callq 0x10201
testb %al, %al
jne 0x1036c
leaq 0x7083(%rip), %rdi      # 0x173e1
leaq 0x1320(%rip), %rsi      # 0x11685
xorl %eax, %eax
callq 0xf160
leaq 0x1318(%rip), %rdi      # 0x1168b
leaq 0x1254e(%rip), %rsi     # 0x228c8
callq 0x10201
testb %al, %al
jne 0x10398
leaq 0x7057(%rip), %rdi      # 0x173e1
leaq 0x12fa(%rip), %rsi      # 0x1168b
xorl %eax, %eax
callq 0xf160
leaq 0x12f4(%rip), %rdi      # 0x11693
leaq 0x12526(%rip), %rsi     # 0x228cc
callq 0x10201
testb %al, %al
jne 0x103c4
leaq 0x702b(%rip), %rdi      # 0x173e1
leaq 0x12d6(%rip), %rsi      # 0x11693
xorl %eax, %eax
callq 0xf160
leaq 0x12d0(%rip), %rdi      # 0x1169b
leaq 0x124fe(%rip), %rsi     # 0x228d0
callq 0x10201
testb %al, %al
jne 0x103f0
leaq 0x6fff(%rip), %rdi      # 0x173e1
leaq 0x12b2(%rip), %rsi      # 0x1169b
xorl %eax, %eax
callq 0xf160
leaq 0x12ac(%rip), %rdi      # 0x116a3
leaq 0x124d6(%rip), %rsi     # 0x228d4
callq 0x10201
testb %al, %al
jne 0x1041c
leaq 0x6fd3(%rip), %rdi      # 0x173e1
leaq 0x128e(%rip), %rsi      # 0x116a3
xorl %eax, %eax
callq 0xf160
leaq 0x1008(%rip), %rdi      # 0x1142b
leaq 0x124b6(%rip), %rsi     # 0x228e0
callq 0x10201
testb %al, %al
jne 0x10448
leaq 0x6fa7(%rip), %rdi      # 0x173e1
leaq 0xfea(%rip), %rsi       # 0x1142b
xorl %eax, %eax
callq 0xf160
leaq 0xff6(%rip), %rdi       # 0x11445
leaq 0x1248e(%rip), %rsi     # 0x228e4
callq 0x10201
testb %al, %al
jne 0x10474
leaq 0x6f7b(%rip), %rdi      # 0x173e1
leaq 0xfd8(%rip), %rsi       # 0x11445
xorl %eax, %eax
callq 0xf160
leaq 0xea6(%rip), %rdi       # 0x11321
leaq 0x12466(%rip), %rsi     # 0x228e8
callq 0x10201
testb %al, %al
je 0x1048d
popq %rax
retq
leaq 0x6f4d(%rip), %rdi      # 0x173e1
leaq 0xe86(%rip), %rsi       # 0x11321
xorl %eax, %eax
popq %rcx
jmp 0xf160
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/parse.c
// Function: keycodes_from_keysym
xcb_keycode_t *keycodes_from_keysym(xcb_keysym_t keysym)
{
	xcb_setup_t const *setup;
	unsigned int num = 0;
	xcb_keycode_t *result = NULL, *result_np = NULL;

	if ((setup = xcb_get_setup(dpy)) != NULL) {
		xcb_keycode_t min_kc = setup->min_keycode;
		xcb_keycode_t max_kc = setup->max_keycode;

		/* We must choose a type for kc other than xcb_keycode_t whose size
		 * is 1, otherwise, since max_kc will most likely be 255, if kc == 255,
		 * kc++ would be 0 and the outer loop would start over ad infinitum */
		for(unsigned int kc = min_kc; kc <= max_kc; kc++)
			for(unsigned int col = 0; col < KEYSYMS_PER_KEYCODE; col++) {
				xcb_keysym_t ks = xcb_key_symbols_get_keysym(symbols, kc, col);
				if (ks == keysym) {
					num++;
					result_np = realloc(result, sizeof(xcb_keycode_t) * (num + 1));
					if (result_np == NULL) {
						free(result);
						return NULL;
					}
					result = result_np;
					result[num - 1] = kc;
					result[num] = XCB_NO_SYMBOL;
					break;
				}
			}
	}
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
leaq 0x11f85(%rip), %rax     # 0x22478
movq (%rax), %rdi
callq 0xe350
xorl %r12d, %r12d
testq %rax, %rax
je 0x10588
movzbl 0x22(%rax), %r13d
movzbl 0x23(%rax), %eax
movl %eax, 0x14(%rsp)
leaq 0x11f6d(%rip), %r14     # 0x22488
movq $0x0, 0x8(%rsp)
cmpl 0x14(%rsp), %r13d
ja 0x10579
xorl %ebp, %ebp
movzbl %r13b, %r15d
cmpl $0x4, %ebp
je 0x10574
movq (%r14), %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0xe250
incl %ebp
cmpl %ebx, %eax
jne 0x10531
leal 0x2(%r12), %esi
movq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe2d0
testq %rax, %rax
je 0x10580
movl %r12d, %ecx
incl %r12d
movb %r13b, (%rax,%rcx)
movb $0x0, (%rax,%r12)
movq %rax, 0x8(%rsp)
incl %r13d
jmp 0x10524
movq 0x8(%rsp), %rax
jmp 0x1058a
movq %r15, %rdi
callq 0xe040
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/types.c
// Function: abort_chain
void abort_chain(void)
{
	PUTS("abort chain");
	put_status(END_CHAIN_PREFIX, "End chain");
	for (hotkey_t *hk = hotkeys_head; hk != NULL; hk = hk->next)
		hk->chain->state = hk->chain->head;
	chained = false;
	locked = false;
	if (timeout > 0)
		alarm(0);
	ungrab();
	grab();
}

// Assembly:
pushq %rax
leaq 0x6b53(%rip), %rsi      # 0x17450
pushq $0x45
popq %rdi
callq 0xed3a
leaq 0x11ba4(%rip), %rax     # 0x224b0
movq (%rax), %rax
testq %rax, %rax
je 0x10926
movq (%rax), %rcx
movq (%rcx), %rdx
movq %rdx, 0x10(%rcx)
addq $0x218, %rax            # imm = 0x218
jmp 0x1090c
leaq 0x11b54(%rip), %rax     # 0x22481
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x11b48(%rip), %rax     # 0x22480
movb %cl, (%rax)
leaq 0x11a13(%rip), %rax     # 0x22354
cmpl $0x0, (%rax)
jle 0x1094d
xorl %edi, %edi
callq 0xe1c0
callq 0xf10d
popq %rax
jmp 0xedbc
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/types.c
// Function: chains_interfere
bool chains_interfere(chain_t* a, chain_t* b) {
	chord_t* i = a->head;
	chord_t* j = b->head;
	for (; i && j; i = i->next, j = j->next) {
		bool match = false;
		for (chord_t* k = i; k; k = k->more) {
			if (match_chord(j, k->event_type, k->keysym, k->button, k->modfield)) {
				match = true;
				break;
			}
		}
		if (!match) {
			break;
		}
	}
	bool result = !i || !j;
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x110, %r15d           # imm = 0x110
movq (%r14), %r14
movq (%rbx), %rbx
testq %r14, %r14
sete %al
testq %rbx, %rbx
sete %bpl
orb %al, %bpl
jne 0x109cd
movq %r14, %r12
testq %r12, %r12
je 0x109cd
movzbl 0x108(%r12), %esi
movl 0x100(%r12), %edx
movzbl 0x104(%r12), %ecx
movzwl 0x106(%r12), %r8d
movq %rbx, %rdi
callq 0x108b4
testb %al, %al
jne 0x109c5
movq 0x118(%r12), %r12
jmp 0x10987
addq %r15, %r14
addq %r15, %rbx
jmp 0x1096c
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/types.c
// Function: make_cycle
cycle_t *make_cycle(int delay, int period)
{
	cycle_t *cycle = malloc(sizeof(cycle_t));
	cycle->delay = delay;
	cycle->period = period;
	return cycle;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
pushq $0x8
popq %rdi
callq 0xe270
movl %ebp, 0x4(%rax)
movl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/types.c
// Function: make_hotkey
hotkey_t *make_hotkey(chain_t *chain, char *command)
{
	hotkey_t *hk = malloc(sizeof(hotkey_t));
	hk->chain = chain;
	hk->sync = false;
	if (command[0] == SYNCHRONOUS_CHAR) {
		command = lgraph(command+1);
		hk->sync = true;
	}
	snprintf(hk->command, sizeof(hk->command), "%s", command);
	hk->cycle = NULL;
	hk->next = hk->prev = NULL;
	return hk;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x228, %edi            # imm = 0x228
callq 0xe270
movq %rax, %rbx
movq %r15, (%rax)
movb $0x0, 0x208(%rax)
cmpb $0x3b, (%r14)
jne 0x10c41
incq %r14
movq %r14, %rdi
callq 0xf362
movq %rax, %r14
movb $0x1, 0x208(%rbx)
movq %rbx, %rdi
addq $0x8, %rdi
leaq 0x4d8(%rip), %rdx       # 0x11127
movl $0x200, %esi            # imm = 0x200
movq %r14, %rcx
xorl %eax, %eax
callq 0xe170
xorps %xmm0, %xmm0
movups %xmm0, 0x210(%rbx)
andq $0x0, 0x220(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/types.c
// Function: add_hotkey
void add_hotkey(hotkey_t *hk)
{
	if (hotkeys_head == NULL) {
		hotkeys_head = hotkeys_tail = hk;
	} else {
		hotkeys_tail->next = hk;
		hk->prev = hotkeys_tail;
		hotkeys_tail = hk;
	}
}

// Assembly:
leaq 0x11830(%rip), %rax     # 0x224b0
cmpq $0x0, (%rax)
je 0x10ca0
leaq 0x1181b(%rip), %rax     # 0x224a8
movq (%rax), %rax
movq %rdi, 0x218(%rax)
movq %rax, 0x220(%rdi)
jmp 0x10ca3
movq %rdi, (%rax)
leaq 0x117fe(%rip), %rax     # 0x224a8
movq %rdi, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/types.c
// Function: destroy_chain
void destroy_chain(chain_t *chain)
{
	chord_t *c = chain->head;
	while (c != NULL) {
		chord_t *n = c->next;
		destroy_chord(c);
		c = n;
	}
	free(chain);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x10cce
movq 0x110(%rdi), %r14
callq 0x10cdd
movq %r14, %rdi
jmp 0x10cb8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe040
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]sxhkd/src/types.c
// Function: destroy_chord
void destroy_chord(chord_t *chord)
{
	chord_t *c = chord->more;
	while (c != NULL) {
		chord_t *n = c->more;
		free(c);
		c = n;
	}
	free(chord);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x118(%rdi), %rdi
testq %rdi, %rdi
je 0x10d01
movq 0x118(%rdi), %r14
callq 0xe040
movq %r14, %rdi
jmp 0x10ceb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe040
// File: /workspace/github_c_makefile_star2_O2/begriffs[P]pthread-test/alarm_fork.c
// Function: main
int main(void)
{
	int seconds;
	char line[128], message[64];
	pid_t pid;

	while (printf("Alarm> ") &&
			fgets(line, sizeof(line), stdin))
	{
		if (strlen(line) <= 1)
			continue;
		if (sscanf(line, "%d %64[^\n]", &seconds, message) < 2)
			fputs("Bad command\n", stderr);
		else
		{
			if ((pid = fork()) == 0)
			{
				sleep(seconds);
				printf("(%d) %s\n", seconds, message);
				exit(EXIT_SUCCESS);
			}
			else if (pid > 0)
			{
				do
				{
					/* collect kids who have finished */
					pid = waitpid(-1, NULL, WNOHANG);
				} while (pid > 0);
			}
			else
				fputs("Failed fork()\n", stderr);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
leaq 0xe30(%rip), %rbx       # 0x2004
movq 0x2dfd(%rip), %r12      # 0x3fd8
leaq 0x50(%rsp), %r14
leaq 0xe30(%rip), %r13       # 0x2017
pushq $-0x1
popq %rbp
pushq $0x1
popq %r15
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
testl %eax, %eax
je 0x127b
movq (%r12), %rdx
movq %r14, %rdi
movl $0x80, %esi
callq 0x1060
testq %rax, %rax
je 0x127b
movq %r14, %rdi
callq 0x1030
cmpq $0x2, %rax
jb 0x11ee
movq %r14, %rdi
leaq 0xde2(%rip), %rsi       # 0x200c
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
xorl %eax, %eax
callq 0x1070
movq %r13, %rdi
cmpl $0x2, %eax
jl 0x1267
callq 0x10b0
testl %eax, %eax
je 0x128f
leaq 0xdda(%rip), %rdi       # 0x202d
jle 0x1267
movl %ebp, %edi
xorl %esi, %esi
movl %r15d, %edx
callq 0x1080
testl %eax, %eax
jg 0x1255
jmp 0x11ee
movq 0x2d8a(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
callq 0x1050
jmp 0x11ee
xorl %eax, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0xc(%rsp), %edi
callq 0x10a0
movl 0xc(%rsp), %esi
leaq 0xd81(%rip), %rdi       # 0x2024
leaq 0x10(%rsp), %rdx
xorl %eax, %eax
callq 0x1040
xorl %edi, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/bench-base64unpack.c
// Function: wrap_LOOP
static inline uint64_t wrap_LOOP(
	bool (*unpack)(const char *s, uint32_t *v, unsigned *e),
	const char *s, uint32_t *v, unsigned *e,
	unsigned n, unsigned c)
{
    uint64_t t = rdtsc();
    asm volatile("" ::: "memory");
    const char *s_end = s + LOOP*c;
    do {
	bool ok = unpack(s, v, e);
	if (!ok)
	    return 0;
	v += n, s += c, e++;
    } while (s < s_end);
    asm volatile("" ::: "memory");
    return rdtsc() - t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r14d
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, 0x10(%rsp)
rdtsc
shlq $0x20, %rdx
orq %rax, %rdx
movq %rdx, 0x8(%rsp)
movl %r9d, %ebx
shll $0x8, %r14d
addq %rsi, %r14
movl %r8d, %ebp
shlq $0x2, %rbp
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x10(%rsp)
testb %al, %al
je 0x11e4
addq $0x4, %r15
addq %rbx, %r13
addq %rbp, %r12
cmpq %r14, %r13
jb 0x11b4
rdtsc
shlq $0x20, %rdx
orq %rax, %rdx
subq 0x8(%rsp), %rdx
jmp 0x11e6
xorl %edx, %edx
movq %rdx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack5x19c16e1
static inline bool unpack5x19c16e1(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x, y;
    if (!unpack6(s, &x)) return false;
    *e = VEXTR32(x, 0) & 1;
    x = glue24(glue12(x));
    y = VSHUF8(x, V8x16_C(
	    -1, -1, -1, 0, -1, -1,  0, 1,
	    -1, -1, -1, 1, -1, -1, -1, 2));
    y = VSHLV32(y, 2, 5, 0, 3);
    VSTORE(v + 0, VSHR32(y, 27));
    y = VSHUF8(x, V8x16_C(
	    -1, -1, 2, 4, -1, -1, -1, 4,
	    -1, -1, 4, 5, -1, -1,  5, 6));
    y = VSHLV32(y, 6, 1, 4, 7);
    VSTORE(v + 4, VSHR32(y, 27));
    y = VSHUF8(x, V8x16_C(
	    -1, -1, -1, 6, -1, -1, 6, 8,
	    -1, -1, -1, 8, -1, -1, 8, 9));
    y = VSHLV32(y, 2, 5, 0, 3);
    VSTORE(v + 8, VSHR32(y, 27));
    y = VSHUF8(x, V8x16_C(
	    -1, -1,  9, 10, -1, -1, -1, 10,
	    -1, -1, 10, 12, -1, -1, 12, 13));
    y = VSHLV32(y, 6, 1, 4, 7);
    VSTORE(v + 12, VSHR32(y, 27));
    y = VSHUF8(x, V8x16_C(
	    -1, -1, -1, 13, -1, -1, 13, 14,
	    -1, -1, -1, 14, -1, -1, -1, -1));
    y = VSHLV32(y, 2, 5, 0, 3);
    VSTORE(v + 16, VSHR32(y, 27));
    return (void) e, true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x12c1
movl (%rsp), %ecx
andl $0x1, %ecx
vmovdqa (%rsp), %xmm0
vpmaddubsw 0x6d27(%rip), %xmm0, %xmm0 # 0x7f50
vpmaddwd 0x6d2f(%rip), %xmm0, %xmm0 # 0x7f60
vpshufb 0x6d36(%rip), %xmm0, %xmm1 # 0x7f70
movl %ecx, (%r14)
vpmovsxbd 0x728e(%rip), %xmm2 # 0x84d4
vpbroadcastd 0x7281(%rip), %xmm3 # 0x84d0
vpsrlvd %xmm2, %xmm1, %xmm1
vpand %xmm3, %xmm1, %xmm1
vpshufb 0x6d2f(%rip), %xmm0, %xmm4 # 0x7f90
vmovdqu %xmm1, (%rbx)
vpmovsxbd 0x726a(%rip), %xmm1 # 0x84d8
vpsrlvd %xmm1, %xmm4, %xmm4
vpand %xmm3, %xmm4, %xmm4
vmovdqu %xmm4, 0x10(%rbx)
vpshufb 0x6d2b(%rip), %xmm0, %xmm4 # 0x7fb0
vpsrlvd %xmm2, %xmm4, %xmm4
vpand %xmm3, %xmm4, %xmm4
vmovdqu %xmm4, 0x20(%rbx)
vpshufb 0x6d24(%rip), %xmm0, %xmm4 # 0x7fc0
vpsrlvd %xmm1, %xmm4, %xmm1
vpand %xmm3, %xmm1, %xmm1
vpshufb 0x6d22(%rip), %xmm0, %xmm0 # 0x7fd0
vmovdqu %xmm1, 0x30(%rbx)
vpsrlvd %xmm2, %xmm0, %xmm0
vpand %xmm3, %xmm0, %xmm0
vmovdqu %xmm0, 0x40(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack6x16c16
static inline bool unpack6x16c16(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack6(s, &x)) return false;
    VSTORE(v + 0, VAND(x, VDUP32(Mask(6))));
    VSTORE(v + 4, VSHUF8(x, V8x16_C(
	     1, -1, -1, -1,  5, -1, -1, -1,
	     9, -1, -1, -1, 13, -1, -1, -1)));
    VSTORE(v + 8, VSHUF8(x, V8x16_C(
	     2, -1, -1, -1,  6, -1, -1, -1,
	    10, -1, -1, -1, 14, -1, -1, -1)));
    VSTORE(v + 12, VSHR32(x, 24));
    return (void) e, true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x1335
vmovdqa (%rsp), %xmm0
vpbroadcastq 0x7209(%rip), %xmm1 # 0x8510
vpand %xmm1, %xmm0, %xmm1
vmovdqu %xmm1, (%rbx)
vpshufb 0x6cc8(%rip), %xmm0, %xmm1 # 0x7fe0
vpshufb 0x6ccf(%rip), %xmm0, %xmm2 # 0x7ff0
vmovdqu %xmm1, 0x10(%rbx)
vmovdqu %xmm2, 0x20(%rbx)
vpsrld $0x18, %xmm0, %xmm0
vmovdqu %xmm0, 0x30(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack7x12c14
static inline bool unpack7x12c14(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    V32x4 mask = VDUP32(Mask(7));
    if (!unpack6(s - 2, &x)) return false;
    x = VSHUF8(x, V8x16_C(
	    2,  3,  4,  5,  5,  6,  7,  8,
	    9, 10, 11, 12, 12, 13, 14, 15));
    x = glue24(glue12(x));
#ifdef VSHRV32
    x = VSHRV32(x, 0, 3, 0, 3);
#else
    x = VBLEND16(VSHR32(x, 3), x, 0x33);
#endif
    VSTORE(v + 0, VAND(x, mask));
    VSTORE(v + 4, VAND(VSHR32(x, 7), mask));
    VSTORE(v + 8, VAND(VSHR32(x, 14), mask));
    return (void) e, true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
addq $-0x2, %rdi
movq %rsp, %rsi
callq 0x6bf8
testb %al, %al
je 0x13cd
vmovdqa (%rsp), %xmm0
vpshufb 0x6c82(%rip), %xmm0, %xmm0 # 0x8000
vpmaddubsw 0x6bc9(%rip), %xmm0, %xmm0 # 0x7f50
vpmaddwd 0x6bd1(%rip), %xmm0, %xmm0 # 0x7f60
vpsrlvd 0x6c78(%rip), %xmm0, %xmm1 # 0x8010
vpbroadcastq 0x7177(%rip), %xmm2 # 0x8518
vpand %xmm2, %xmm1, %xmm1
vmovdqu %xmm1, (%rbx)
vpsrlvd 0x6c6e(%rip), %xmm0, %xmm1 # 0x8020
vpand %xmm2, %xmm1, %xmm1
vmovdqu %xmm1, 0x10(%rbx)
vpsrlvd 0x6c6c(%rip), %xmm0, %xmm0 # 0x8030
vpand %xmm2, %xmm0, %xmm0
vmovdqu %xmm0, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
retq