LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hcmiya[P]opuscomment/src/error.c
// Function: opuserror
noreturn void opuserror(int e, ...) {
	va_list ap;
	va_start(ap, e);
	errorprefix();
	
	struct {
		bool report_page;
		char const *default_message;
	} msg[] = {
#define LIST(I, B, E, S) {B, S},
#include "errordef/opus.tab"
#undef LIST
	};
	if (msg[e].report_page && codec->type != CODEC_FLAC) {
		fprintf(stderr, catgets(catd, 1, 4, "%s format error: page %u: "), codec->name, opus_idx);
	}
	else {
		fprintf(stderr, catgets(catd, 1, 8, "%s format error: "), codec->name);
	}
	vfprintf(stderr, catgets(catd, 3, e, msg[e].default_message), ap);
	fputc('\n', stderr);
	exit(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
testb %al, %al
je 0x86d7
movaps %xmm0, -0x190(%rbp)
movaps %xmm1, -0x180(%rbp)
movaps %xmm2, -0x170(%rbp)
movaps %xmm3, -0x160(%rbp)
movaps %xmm4, -0x150(%rbp)
movaps %xmm5, -0x140(%rbp)
movaps %xmm6, -0x130(%rbp)
movaps %xmm7, -0x120(%rbp)
movq %r9, -0x198(%rbp)
movq %r8, -0x1a0(%rbp)
movq %rcx, -0x1a8(%rbp)
movq %rdx, -0x1b0(%rbp)
movq %rsi, -0x1b8(%rbp)
movl %edi, -0x4(%rbp)
leaq -0x20(%rbp), %rax
leaq -0x1c0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
callq 0x8510
leaq -0x110(%rbp), %rdi
leaq 0x456c(%rip), %rsi      # 0xcca0
movl $0xf0, %edx
callq 0x22d0
movslq -0x4(%rbp), %rcx
leaq -0x110(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
testb $0x1, (%rax)
je 0x87bf
leaq 0x14f54(%rip), %rax     # 0x1d6b0
movq (%rax), %rax
cmpl $0x2, (%rax)
je 0x87bf
movq 0x488d(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x1c8(%rbp)
leaq 0x14f44(%rip), %rax     # 0x1d6c0
movq (%rax), %rdi
movl $0x1, %esi
movl $0x4, %edx
leaq 0x1d51(%rip), %rcx      # 0xa4e1
callq 0x2460
movq -0x1c8(%rbp), %rdi
movq %rax, %rsi
leaq 0x14f0a(%rip), %rax     # 0x1d6b0
movq (%rax), %rax
movq 0x10(%rax), %rdx
leaq 0x14f5c(%rip), %rax     # 0x1d710
movl (%rax), %ecx
movb $0x0, %al
callq 0x2290
jmp 0x880f
movq 0x4832(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x1d0(%rbp)
leaq 0x14ee9(%rip), %rax     # 0x1d6c0
movq (%rax), %rdi
movl $0x1, %esi
movl $0x8, %edx
leaq 0x1d11(%rip), %rcx      # 0xa4fc
callq 0x2460
movq -0x1d0(%rbp), %rdi
movq %rax, %rsi
leaq 0x14eaf(%rip), %rax     # 0x1d6b0
movq (%rax), %rax
movq 0x10(%rax), %rdx
movb $0x0, %al
callq 0x2290
movq 0x47e2(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x1d8(%rbp)
leaq 0x14e99(%rip), %rax     # 0x1d6c0
movq (%rax), %rdi
movl -0x4(%rbp), %edx
movslq -0x4(%rbp), %rcx
leaq -0x110(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movl $0x3, %esi
callq 0x2460
movq -0x1d8(%rbp), %rdi
movq %rax, %rsi
leaq -0x20(%rbp), %rdx
callq 0x2420
movq 0x4791(%rip), %rax      # 0xcff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2210
movl $0x2, %edi
callq 0x2480
nop
// File: /workspace/github_c_makefile_star2_O0/hcmiya[P]opuscomment/src/error.c
// Function: oserror_fmt
noreturn void oserror_fmt(char const *e, ...) {
	va_list ap;
	va_start(ap, e);
	errorprefix();
	vfprintf(stderr, e, ap);
	fputc('\n', stderr);
	exit(3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x88d5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
callq 0x8510
movq 0x46cc(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2420
movq 0x46b5(%rip), %rax      # 0xcff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2210
movl $0x3, %edi
callq 0x2480
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hcmiya[P]opuscomment/src/error.c
// Function: fileerror
noreturn void fileerror(char const *file) {
	errorprefix();
	fprintf(stderr, catgets(catd, 1, 5, "%s: "), file);
	perror(NULL);
	exit(3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x8510
movq 0x4680(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0x14d3a(%rip), %rax     # 0x1d6c0
movq (%rax), %rdi
movl $0x1, %esi
movl $0x5, %edx
leaq 0x1895(%rip), %rcx      # 0xa22f
callq 0x2460
movq -0x10(%rbp), %rdi
movq %rax, %rsi
movq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x2290
xorl %eax, %eax
movl %eax, %edi
callq 0x23f0
movl $0x3, %edi
callq 0x2480
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hcmiya[P]opuscomment/src/error.c
// Function: opterror
noreturn void opterror(int c, char const *e, ...) {
	va_list ap;
	va_start(ap, e);
	errorprefix();
	fprintf(stderr, catgets(catd, 1, 7, "-%c: "), c);
	vfprintf(stderr, e, ap);
	fputc('\n', stderr);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x8a08
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
callq 0x8510
movq 0x459d(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0xe8(%rbp)
leaq 0x14c54(%rip), %rax     # 0x1d6c0
movq (%rax), %rdi
movl $0x1, %esi
movl $0x7, %edx
leaq 0x1a8e(%rip), %rcx      # 0xa50e
callq 0x2460
movq -0xe8(%rbp), %rdi
movq %rax, %rsi
movl -0x4(%rbp), %edx
movb $0x0, %al
callq 0x2290
movq 0x4558(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2420
movq 0x4541(%rip), %rax      # 0xcff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2210
movl $0x1, %edi
callq 0x2480
nop
// File: /workspace/github_c_makefile_star2_O0/hcmiya[P]opuscomment/src/main.c
// Function: read_ogg
static void read_ogg(void) {
	ogg_sync_state oy;
	ogg_sync_init(&oy);
	
	size_t buflen = 1 << 17;
	uint8_t *buf = ogg_sync_buffer(&oy, buflen);
	size_t len = fread(buf, 1, buflen, stream_input);
	if (len == (size_t)-1) oserror();
	if (len < 4) {
		opuserror(err_opus_non_ogg);
	}
	if (memcmp(buf, "\x4f\x67\x67\x53", 4) != 0) {
		opuserror(err_opus_non_ogg);
	}
	ogg_sync_wrote(&oy, len);
	read_page(&oy);
	
	for (;;) {
		buf = ogg_sync_buffer(&oy, buflen);
		len = fread(buf, 1, buflen, stream_input);
		if (!len) {
			break;
		}
		ogg_sync_wrote(&oy, len);
		read_page(&oy);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x20(%rbp), %rdi
callq 0x24b0
movq $0x20000, -0x28(%rbp)   # imm = 0x20000
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x21f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq 0x14237(%rip), %rcx     # 0x1d700
movl $0x1, %esi
callq 0x20e0
movq %rax, -0x38(%rbp)
cmpq $-0x1, -0x38(%rbp)
jne 0x94e3
callq 0x8880
cmpq $0x4, -0x38(%rbp)
jae 0x94f6
movl $0x1, %edi
movb $0x0, %al
callq 0x8690
movq -0x30(%rbp), %rax
movl (%rax), %eax
subl $0x5367674f, %eax       # imm = 0x5367674F
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x9518
movl $0x1, %edi
movb $0x0, %al
callq 0x8690
movq -0x38(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x2240
leaq -0x20(%rbp), %rdi
callq 0x5b40
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x21f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq 0x141b2(%rip), %rcx     # 0x1d700
movl $0x1, %esi
callq 0x20e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x9565
jmp 0x957d
movq -0x38(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x2240
leaq -0x20(%rbp), %rdi
callq 0x5b40
jmp 0x952e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/thread_error.c
// Function: main
int main(void)
{
	pthread_t weirdo;
	/* join with an uninitialized value */
	int status = pthread_join(weirdo, NULL);

	if (status != 0)
		fprintf(stderr, "Error %d: %s\n", status, strerror(status));
	else
		fprintf(stderr, "Weird, no error\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1040
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x11bb
movq 0x2e6c(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edi
callq 0x1050
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %edx
movq %rax, %rcx
leaq 0xe52(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1030
jmp 0x11d3
movq 0x2e36(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe46(%rip), %rsi       # 0x2012
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/codeniko[P]CS214-Malloc-Free/Test4.c
// Function: main
void main()
{
    int i;
    int* p = malloc(5 * sizeof(int));
    for(i = 0; i < 5; i++){
        p[i] = i;
    }
    for(i = 0; i < 5; i++){
        printf("address: %p, value: %d\n", p + i, p[i]);
     }
    free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x14, %edi
leaq 0xea0(%rip), %rsi       # 0x2004
movl $0x7, %edx
callq 0x1200
movq %rax, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x5, -0x4(%rbp)
jge 0x1198
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1179
movl $0x0, -0x4(%rbp)
cmpl $0x5, -0x4(%rbp)
jge 0x11d8
movq -0x10(%rbp), %rsi
movslq -0x4(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0xe46(%rip), %rdi       # 0x200c
movb $0x0, %al
callq 0x1030
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x119f
movq -0x10(%rbp), %rdi
leaq 0xe21(%rip), %rsi       # 0x2004
movl $0xe, %edx
callq 0x1400
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/sxhkd.c
// Function: hold
void hold(int sig)
{
	if (sig == SIGHUP || sig == SIGINT || sig == SIGTERM)
		running = false;
	else if (sig == SIGUSR1)
		reload = true;
	else if (sig == SIGUSR2)
		toggle_grab = true;
	else if (sig == SIGALRM)
		bell = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x1, -0x4(%rbp)
je 0xeb69
cmpl $0x2, -0x4(%rbp)
je 0xeb69
cmpl $0xf, -0x4(%rbp)
jne 0xeb72
movb $0x0, 0x14925(%rip)     # 0x23495
jmp 0xeba3
cmpl $0xa, -0x4(%rbp)
jne 0xeb81
movb $0x1, 0x14915(%rip)     # 0x23494
jmp 0xeba1
cmpl $0xc, -0x4(%rbp)
jne 0xeb90
movb $0x1, 0x14905(%rip)     # 0x23493
jmp 0xeb9f
cmpl $0xe, -0x4(%rbp)
jne 0xeb9d
movb $0x1, 0x148f5(%rip)     # 0x23492
jmp 0xeb9f
jmp 0xeba1
jmp 0xeba3
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
movl %eax, %edi
leaq -0x4(%rbp), %rsi
callq 0xe0f0
movq %rax, 0x148bc(%rip)     # 0x23488
movq 0x148b5(%rip), %rdi     # 0x23488
callq 0xe310
cmpl $0x0, %eax
je 0xebeb
leaq 0x45ef(%rip), %rdi      # 0x131d3
movb $0x0, %al
callq 0xf6e0
movq $0x0, -0x10(%rbp)
movq 0x1488e(%rip), %rdi     # 0x23488
callq 0xe350
movq %rax, %rdi
callq 0xe210
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xec3b
cmpl $0x0, -0x4(%rbp)
jne 0xec25
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xec3b
jmp 0xec27
leaq -0x20(%rbp), %rdi
callq 0xe1b0
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xec0f
cmpq $0x0, -0x10(%rbp)
jne 0xec50
leaq 0x459f(%rip), %rdi      # 0x131e8
movb $0x0, %al
callq 0xf6e0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, 0x1484c(%rip)     # 0x234a8
leaq 0x459c(%rip), %rdi      # 0x131ff
callq 0xe030
movq %rax, 0x14841(%rip)     # 0x234b0
cmpq $0x0, %rax
jne 0xeca3
leaq 0x4589(%rip), %rdi      # 0x13205
callq 0xe030
movq %rax, 0x14828(%rip)     # 0x234b0
cmpq $0x0, %rax
jne 0xeca3
leaq 0x4576(%rip), %rdi      # 0x1320b
leaq 0x4569(%rip), %rsi      # 0x13205
movb $0x0, %al
callq 0xf6e0
movq 0x147de(%rip), %rdi     # 0x23488
callq 0xe100
movq %rax, 0x147e2(%rip)     # 0x23498
movq $0x0, 0x147f7(%rip) # 0x234b8
movq $0x0, 0x147f4(%rip) # 0x234c0
movb $0x0, 0x147fd(%rip)     # 0x234d0
callq 0xe0b0
movl %eax, %ecx
leaq 0x14aef(%rip), %rdi     # 0x237d0
movl $0x100, %esi            # imm = 0x100
leaq 0x4401(%rip), %rdx      # 0x130ee
movb $0x0, %al
callq 0xe170
leaq 0x453f(%rip), %rdi      # 0x1323a
leaq 0x14ace(%rip), %rsi     # 0x237d0
movl $0x1, %edx
callq 0xe0a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
movw $0x0, -0x14(%rbp)
movzwl 0x14752(%rip), %eax     # 0x234a0
movzwl 0x1474d(%rip), %ecx     # 0x234a2
orl %ecx, %eax
movzwl 0x14746(%rip), %ecx     # 0x234a4
orl %ecx, %eax
movw %ax, -0x16(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rdx
leaq -0x11(%rbp), %rcx
leaq -0x14(%rbp), %r8
movzbl -0x9(%rbp), %esi
callq 0x10040
movzwl -0x16(%rbp), %ecx
xorl $-0x1, %ecx
andl $0xff, %ecx
movzwl -0x14(%rbp), %eax
andl %ecx, %eax
movw %ax, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpq $0x0, %rax
jne 0xeda7
movzbl -0x11(%rbp), %eax
cmpq $0x0, %rax
je 0xedff
movl -0x10(%rbp), %edi
movb -0x11(%rbp), %cl
movw -0x14(%rbp), %ax
leaq -0x12(%rbp), %r8
movzbl %cl, %esi
movzwl %ax, %edx
movzbl -0x9(%rbp), %ecx
callq 0x11640
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xedfd
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rax
movb 0x208(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xf790
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movl $0x43, %edi
callq 0xefc0
jmp 0xedff
movzbl -0x9(%rbp), %eax
movl %eax, -0x34(%rbp)
addl $-0x2, %eax
subl $0x2, %eax
jb 0xee53
jmp 0xee10
movl -0x34(%rbp), %eax
addl $-0x4, %eax
subl $0x1, %eax
ja 0xee89
jmp 0xee1d
testb $0x1, -0x12(%rbp)
je 0xee3b
movq 0x1465e(%rip), %rdi     # 0x23488
movl $0x2, %esi
xorl %edx, %edx
callq 0xe110
movl %eax, -0x24(%rbp)
jmp 0xee51
movq 0x14646(%rip), %rdi     # 0x23488
movl $0x1, %esi
xorl %edx, %edx
callq 0xe110
movl %eax, -0x28(%rbp)
jmp 0xee89
testb $0x1, -0x12(%rbp)
je 0xee71
movq 0x14628(%rip), %rdi     # 0x23488
movl $0x5, %esi
xorl %edx, %edx
callq 0xe110
movl %eax, -0x2c(%rbp)
jmp 0xee87
movq 0x14610(%rip), %rdi     # 0x23488
movl $0x4, %esi
xorl %edx, %edx
callq 0xe110
movl %eax, -0x30(%rbp)
jmp 0xee89
movq 0x145f8(%rip), %rdi     # 0x23488
callq 0xe130
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x144ad(%rip)     # 0x23360
jne 0xeeb7
jmp 0xef36
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x2, %eax
jne 0xeece
jmp 0xef36
movq 0x145c3(%rip), %rdi     # 0x23498
movq -0x10(%rbp), %rsi
callq 0xe050
cmpl $0x1, %eax
jne 0xef36
movq 0x14596(%rip), %rdi     # 0x23480
callq 0x12260
callq 0x114b0
callq 0xef40
movl 0x14471(%rip), %edi     # 0x23370
xorl %r9d, %r9d
movl $0x2, %ecx
movl %r9d, %esi
movl %r9d, %edx
movl %r9d, %r8d
callq 0x11ca0
movq %rax, 0x14564(%rip)     # 0x23480
cmpl $0x0, 0x1443d(%rip)     # 0x23360
jle 0xef34
movl 0x14435(%rip), %eax     # 0x23360
addl $-0x1, %eax
movl %eax, 0x1442c(%rip)     # 0x23360
jmp 0xef36
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xf010
leaq 0x1442c(%rip), %rdi     # 0x23380
callq 0xfa10
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x1440b(%rip), %eax     # 0x23374
jge 0xef8a
movq 0x14406(%rip), %rax     # 0x23378
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xfa10
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xef60
callq 0xf5d0
callq 0xf090
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/sxhkd.c
// Function: toggle_grab_cmd
void toggle_grab_cmd(void)
{
	PUTS("toggle grab");
	if (grabbed) {
		ungrab();
	} else {
		grab();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testb $0x1, 0x143bd(%rip)     # 0x23368
je 0xefb4
callq 0xf5d0
jmp 0xefb9
callq 0xf090
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/sxhkd.c
// Function: put_status
void put_status(char c, const char *s)
{
	if (status_fifo == NULL) {
		return;
	}
	fprintf(status_fifo, "%c%s\n", c, s);
	fflush(status_fifo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x14376(%rip)     # 0x23350
jne 0xefde
jmp 0xf007
movq 0x1436b(%rip), %rdi     # 0x23350
movsbl -0x1(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq 0x4250(%rip), %rsi      # 0x13244
movb $0x0, %al
callq 0xe230
movq 0x1434e(%rip), %rdi     # 0x23350
callq 0xe280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x144a1(%rip), %rax     # 0x234c0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf068
movq -0x8(%rbp), %rax
movq 0x218(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x12210
movq -0x8(%rbp), %rax
movq 0x210(%rax), %rdi
callq 0xe040
movq -0x8(%rbp), %rdi
callq 0xe040
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf023
movq $0x0, 0x14445(%rip) # 0x234b8
movq $0x0, 0x14442(%rip) # 0x234c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x14421(%rip), %rax     # 0x234c0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf0cd
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xf0f0
movq -0x8(%rbp), %rax
movq 0x218(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xf0a6
leaq 0x143b4(%rip), %rax     # 0x23488
movq (%rax), %rdi
callq 0xe130
leaq 0x14285(%rip), %rax     # 0x23368
movb $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf1f9
movq -0x10(%rbp), %rax
movzbl 0x104(%rax), %eax
cmpq $0x0, %rax
jne 0xf1c4
movq -0x10(%rbp), %rax
movl 0x100(%rax), %edi
callq 0x11500
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xf1b9
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpq $0x0, %rax
je 0xf1b7
movq -0x10(%rbp), %rax
movl 0x100(%rax), %eax
movl %eax, -0x24(%rbp)
leaq 0x14331(%rip), %rax     # 0x23498
movq (%rax), %rdi
movq -0x20(%rbp), %rax
xorl %edx, %edx
movzbl (%rax), %esi
callq 0xe250
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jne 0xf1a7
movq -0x20(%rbp), %rax
movb (%rax), %dl
movq -0x10(%rbp), %rax
movb 0x104(%rax), %cl
movq -0x10(%rbp), %rax
movzbl %dl, %edi
movzbl %cl, %esi
movzwl 0x106(%rax), %edx
callq 0xf200
jmp 0xf1a9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xf146
jmp 0xf1b9
movq -0x18(%rbp), %rdi
callq 0xe040
jmp 0xf1e3
movq -0x10(%rbp), %rax
movb 0x104(%rax), %cl
movq -0x10(%rbp), %rax
xorl %edi, %edi
movzbl %cl, %esi
movzwl 0x106(%rax), %edx
callq 0xf200
jmp 0xf1e5
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf104
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movw %dx, %ax
movb %sil, %cl
movb %dil, %dl
movb %dl, -0x1(%rbp)
movb %cl, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movzbl -0x2(%rbp), %eax
cmpq $0x0, %rax
jne 0xf4be
leaq 0x1401c(%rip), %rax     # 0x23488
movq (%rax), %rax
movq %rax, -0x30(%rbp)
leaq 0x1400e(%rip), %rax     # 0x23488
movq (%rax), %rdi
leaq 0x14024(%rip), %rax     # 0x234a8
movl (%rax), %edx
movw -0x4(%rbp), %ax
movl $0x1, %r9d
xorl %ecx, %ecx
movl %r9d, %esi
movzwl %ax, %ecx
movzbl -0x1(%rbp), %r8d
movl $0x0, (%rsp)
callq 0xe090
movq -0x30(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0xe2a0
movq %rax, -0x10(%rbp)
jmp 0xf529
leaq 0x13fc3(%rip), %rax     # 0x23488
movq (%rax), %rax
movq %rax, -0x38(%rbp)
leaq 0x13fb5(%rip), %rax     # 0x23488
movq (%rax), %rdi
leaq 0x13fcb(%rip), %rax     # 0x234a8
movl (%rax), %edx
movb -0x2(%rbp), %al
movl $0x1, %r9d
movl $0xc, %ecx
xorl %r8d, %r8d
movl %r9d, %esi
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movzbl %al, %eax
movl %eax, 0x10(%rsp)
movzwl -0x4(%rbp), %eax
movl %eax, 0x18(%rsp)
callq 0xe3b0
movq -0x38(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0xe2a0
movq %rax, -0x10(%rbp)
movzbl -0x2(%rbp), %eax
cmpq $0x0, %rax
jne 0xf53c
movzbl -0x1(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0xf543
movzbl -0x2(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movzbl -0x2(%rbp), %eax
movl %eax, %edx
leaq 0x3cf4(%rip), %rax      # 0x1324a
leaq 0x3db3(%rip), %rcx      # 0x13310
cmpq $0x0, %rdx
cmoveq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf5c7
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %edx
movzwl -0x4(%rbp), %ecx
leaq 0x3ccf(%rip), %rdi      # 0x13251
movb $0x0, %al
callq 0xf640
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa, %eax
jne 0xf5a6
leaq 0x3cdc(%rip), %rdi      # 0x13279
movb $0x0, %al
callq 0xf640
jmp 0xf5bc
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %esi
leaq 0x3ce9(%rip), %rdi      # 0x1329e
movb $0x0, %al
callq 0xf640
movq -0x10(%rbp), %rdi
callq 0xe040
jmp 0xf5c9
jmp 0xf5c9
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x13ea9(%rip), %rax     # 0x23488
movq (%rax), %rdi
leaq 0x13ebf(%rip), %rax     # 0x234a8
movl (%rax), %edx
xorl %esi, %esi
movl $0x8000, %ecx           # imm = 0x8000
callq 0xe390
movl %eax, -0x4(%rbp)
leaq 0x13e87(%rip), %rax     # 0x23488
movq (%rax), %rdi
leaq 0x13e9d(%rip), %rax     # 0x234a8
movl (%rax), %edx
xorl %esi, %esi
movl $0x8000, %ecx           # imm = 0x8000
callq 0xe2f0
movl %eax, -0x8(%rbp)
leaq 0x13e65(%rip), %rax     # 0x23488
movq (%rax), %rdi
callq 0xe130
leaq 0x13d36(%rip), %rax     # 0x23368
movb $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/helpers.c
// Function: err
__attribute__((noreturn))
void err(char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);
	exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0xf715
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xb891(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0xe340
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0xe3a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
callq 0xe3e0
cmpl $0x0, %eax
jne 0xf85e
leaq 0x13c73(%rip), %rax     # 0x23488
cmpq $0x0, (%rax)
je 0xf831
leaq 0x13c66(%rip), %rax     # 0x23488
movq (%rax), %rdi
callq 0xe060
movl %eax, %edi
callq 0xe1d0
testb $0x1, -0x9(%rbp)
je 0xf842
movq -0x8(%rbp), %rdi
callq 0xf870
jmp 0xf85c
callq 0xe3e0
cmpl $0x0, %eax
jne 0xf855
movq -0x8(%rbp), %rdi
callq 0xf870
xorl %edi, %edi
callq 0xe3a0
jmp 0xf85e
xorl %eax, %eax
movl %eax, %edi
callq 0xe3c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0xe1e0
leaq 0x13ae4(%rip), %rax     # 0x2336c
cmpl $-0x1, (%rax)
je 0xf8b3
leaq 0x13ad8(%rip), %rax     # 0x2336c
movl (%rax), %edi
movl $0x1, %esi
callq 0xe140
leaq 0x13ac5(%rip), %rax     # 0x2336c
movl (%rax), %edi
movl $0x2, %esi
callq 0xe140
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xe360
leaq 0x39ee(%rip), %rdi      # 0x132b8
movb $0x0, %al
callq 0xf6e0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe120
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x1d(%rbp)
jae 0xf93a
callq 0xe400
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl -0x1c(%rbp), %edx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xf943
jmp 0xf94e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf900
movl -0x1c(%rbp), %eax
cmpq -0x18(%rbp), %rax
jae 0xf967
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xf96f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/helpers.c
// Function: rgraph
char *rgraph(char *s)
{
	int i = strlen(s) - 1;
	while (i >= 0 && !isgraph(s[i]))
		i--;
	if (i >= 0)
		return (s + i);
	else
		return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe120
subq $0x1, %rax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x15(%rbp)
jl 0xf9d2
callq 0xe400
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xf9db
jmp 0xf9e6
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf99c
cmpl $0x0, -0x14(%rbp)
jl 0xf9fd
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xfa05
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x2, %eax
jne 0x100aa
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x31(%rbp)
movq -0x30(%rbp), %rax
movw 0x1c(%rax), %cx
movq -0x28(%rbp), %rax
movw %cx, (%rax)
leaq 0x13409(%rip), %rax     # 0x23498
movq (%rax), %rdi
xorl %edx, %edx
movzbl -0x31(%rbp), %esi
callq 0xe250
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x10172
movzbl -0x9(%rbp), %eax
cmpl $0x3, %eax
jne 0x10110
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x41(%rbp)
movq -0x40(%rbp), %rax
movzwl 0x1c(%rax), %eax
movl %eax, -0x5c(%rbp)
movzbl -0x41(%rbp), %edi
callq 0x10180
movw %ax, %cx
movl -0x5c(%rbp), %eax
movswl %cx, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, (%rax)
leaq 0x133a0(%rip), %rax     # 0x23498
movq (%rax), %rdi
xorl %edx, %edx
movzbl -0x41(%rbp), %esi
callq 0xe250
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x10170
movzbl -0x9(%rbp), %eax
cmpl $0x4, %eax
jne 0x1013f
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x50(%rbp), %rax
movw 0x1c(%rax), %cx
movq -0x28(%rbp), %rax
movw %cx, (%rax)
jmp 0x1016e
movzbl -0x9(%rbp), %eax
cmpl $0x5, %eax
jne 0x1016c
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x58(%rbp), %rax
movw 0x1c(%rax), %cx
movq -0x28(%rbp), %rax
movw %cx, (%rax)
jmp 0x1016e
jmp 0x10170
jmp 0x10172
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movw $0x0, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x132dd(%rip), %rax     # 0x23488
movq (%rax), %rax
movq %rax, -0x38(%rbp)
leaq 0x132cf(%rip), %rax     # 0x23488
movq (%rax), %rdi
callq 0xe0c0
movq -0x38(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xe3d0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x102b2
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x0, %eax
jle 0x102b2
movq -0x18(%rbp), %rdi
callq 0xe080
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x102b0
movq -0x18(%rbp), %rdi
callq 0xe0d0
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x102ae
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jae 0x1029e
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rdx
movzbl 0x1(%rdx), %edx
imull %edx, %ecx
addl -0x28(%rbp), %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpq $0x0, %rax
jne 0x1026f
jmp 0x10293
movzbl -0x1(%rbp), %eax
movzbl -0x29(%rbp), %ecx
cmpl %ecx, %eax
jne 0x10291
movl -0x24(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movzwl -0x4(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x4(%rbp)
jmp 0x10293
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x10237
jmp 0x102a0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10228
jmp 0x102b0
jmp 0x102b2
movq -0x18(%rbp), %rdi
callq 0xe040
movw -0x4(%rbp), %ax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1051d
movq -0x10(%rbp), %rax
movq 0x410(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe040
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x104f4
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/parse.c
// Function: make_chunk
chunk_t *make_chunk(void)
{
	chunk_t *c = calloc(1, sizeof(chunk_t));
	c->sequence = false;
	c->advance = NULL;
	c->next = NULL;
	c->range_cur = 1;
	c->range_max = 0;
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x418, %esi            # imm = 0x418
callq 0xe200
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x408(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x400(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x410(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x409(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x40a(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq $0x812, %rax            # imm = 0x812
jae 0x11152
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0xa112(%rip), %rax      # 0x1b220
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xe220
cmpl $0x0, %eax
jne 0x11145
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x11156
jmp 0x11147
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x110f7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/parse.c
// Function: key_to_button
uint8_t key_to_button(uint8_t event_type)
{
	if (event_type == XCB_KEY_PRESS)
		return XCB_BUTTON_PRESS;
	else if (event_type == XCB_KEY_RELEASE)
		return XCB_BUTTON_RELEASE;
	return event_type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0x2, %eax
jne 0x111c9
movb $0x4, -0x1(%rbp)
jmp 0x111e0
movzbl -0x2(%rbp), %eax
cmpl $0x3, %eax
jne 0x111d8
movb $0x5, -0x1(%rbp)
jmp 0x111e0
jmp 0x111da
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movw $0x0, -0x6(%rbp)
movq $0x0, -0x10(%rbp)
movl -0x4(%rbp), %edi
callq 0x11500
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x11259
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpq $0x0, %rax
je 0x11257
movq -0x18(%rbp), %rax
movzbl (%rax), %edi
callq 0x10180
movswl %ax, %ecx
movzwl -0x6(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x6(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x11223
jmp 0x11259
movq -0x10(%rbp), %rdi
callq 0xe040
movw -0x6(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/parse.c
// Function: parse_fold
bool parse_fold(char *string, char *folded_string)
{
	if (strchr(string, SEQ_BEGIN) != NULL && strrchr(string, SEQ_END) != NULL) {
		snprintf(folded_string, strlen(string), "%s", string);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x7b, %esi
callq 0xe150
cmpq $0x0, %rax
je 0x112d8
movq -0x10(%rbp), %rdi
movl $0x7d, %esi
callq 0xe180
cmpq $0x0, %rax
je 0x112d8
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe120
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rcx
leaq 0x1eae(%rip), %rdx      # 0x13179
movb $0x0, %al
callq 0xe170
movb $0x1, -0x1(%rbp)
jmp 0x112dc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq 0x2352(%rip), %rdi      # 0x1364d
leaq 0x125ce(%rip), %rsi     # 0x238d0
callq 0x110e0
testb $0x1, %al
jne 0x11322
leaq 0x809d(%rip), %rdi      # 0x193af
leaq 0x2334(%rip), %rsi      # 0x1364d
movb $0x0, %al
callq 0xf640
jmp 0x11324
jmp 0x11324
leaq 0x2328(%rip), %rdi      # 0x13653
leaq 0x125a2(%rip), %rsi     # 0x238d4
callq 0x110e0
testb $0x1, %al
jne 0x11352
leaq 0x806d(%rip), %rdi      # 0x193af
leaq 0x230a(%rip), %rsi      # 0x13653
movb $0x0, %al
callq 0xf640
jmp 0x11354
jmp 0x11354
leaq 0x22fe(%rip), %rdi      # 0x13659
leaq 0x12576(%rip), %rsi     # 0x238d8
callq 0x110e0
testb $0x1, %al
jne 0x11382
leaq 0x803d(%rip), %rdi      # 0x193af
leaq 0x22e0(%rip), %rsi      # 0x13659
movb $0x0, %al
callq 0xf640
jmp 0x11384
jmp 0x11384
leaq 0x22d6(%rip), %rdi      # 0x13661
leaq 0x1254a(%rip), %rsi     # 0x238dc
callq 0x110e0
testb $0x1, %al
jne 0x113b2
leaq 0x800d(%rip), %rdi      # 0x193af
leaq 0x22b8(%rip), %rsi      # 0x13661
movb $0x0, %al
callq 0xf640
jmp 0x113b4
jmp 0x113b4
leaq 0x22ae(%rip), %rdi      # 0x13669
leaq 0x1251e(%rip), %rsi     # 0x238e0
callq 0x110e0
testb $0x1, %al
jne 0x113e2
leaq 0x7fdd(%rip), %rdi      # 0x193af
leaq 0x2290(%rip), %rsi      # 0x13669
movb $0x0, %al
callq 0xf640
jmp 0x113e4
jmp 0x113e4
leaq 0x2286(%rip), %rdi      # 0x13671
leaq 0x124f2(%rip), %rsi     # 0x238e4
callq 0x110e0
testb $0x1, %al
jne 0x11412
leaq 0x7fad(%rip), %rdi      # 0x193af
leaq 0x2268(%rip), %rsi      # 0x13671
movb $0x0, %al
callq 0xf640
jmp 0x11414
jmp 0x11414
leaq 0x1fde(%rip), %rdi      # 0x133f9
leaq 0x124ce(%rip), %rsi     # 0x238f0
callq 0x110e0
testb $0x1, %al
jne 0x11442
leaq 0x7f7d(%rip), %rdi      # 0x193af
leaq 0x1fc0(%rip), %rsi      # 0x133f9
movb $0x0, %al
callq 0xf640
jmp 0x11444
jmp 0x11444
leaq 0x1fc8(%rip), %rdi      # 0x13413
leaq 0x124a2(%rip), %rsi     # 0x238f4
callq 0x110e0
testb $0x1, %al
jne 0x11472
leaq 0x7f4d(%rip), %rdi      # 0x193af
leaq 0x1faa(%rip), %rsi      # 0x13413
movb $0x0, %al
callq 0xf640
jmp 0x11474
jmp 0x11474
leaq 0x1e74(%rip), %rdi      # 0x132ef
leaq 0x12476(%rip), %rsi     # 0x238f8
callq 0x110e0
testb $0x1, %al
jne 0x114a2
leaq 0x7f1d(%rip), %rdi      # 0x193af
leaq 0x1e56(%rip), %rsi      # 0x132ef
movb $0x0, %al
callq 0xf640
jmp 0x114a4
jmp 0x114a4
popq %rbp
retq
nopw %cs:(%rax,%rax)