LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_nameserv_cmp
static int dns_res_nameserv_cmp(struct dns_rr *a, struct dns_rr *b, struct dns_rr_i *i, struct dns_packet *P) {
	_Bool glued[2] = { 0 };
	struct dns_rr x = { 0 }, y = { 0 };
	struct dns_ns ns;
	int cmp, error;

	if (!(error = dns_ns_parse(&ns, a, P)))
		glued[0] = !!dns_rr_grep(&x, 1, dns_rr_i_new(P, .section = (DNS_S_ALL & ~DNS_S_QD), .name = ns.host, .type = DNS_T_A), P, &error);

	if (!(error = dns_ns_parse(&ns, b, P)))
		glued[1] = !!dns_rr_grep(&y, 1, dns_rr_i_new(P, .section = (DNS_S_ALL & ~DNS_S_QD), .name = ns.host, .type = DNS_T_A), P, &error);

	if ((cmp = glued[1] - glued[0])) {
		return cmp;
	} else if ((cmp = (dns_rr_offset(&y) < i->args[0]) - (dns_rr_offset(&x) < i->args[0]))) {
		return cmp;
	} else {
		return dns_rr_i_shuffle(a, b, i, P);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
xorl %ebp, %ebp
movq %rbp, 0x40(%rsp)
movq %rbp, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movzwl 0x14(%rdi), %edx
leaq 0x108(%rsp), %r13
leaq 0x8(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
movq %r13, %rdi
callq 0xfec0
cmpq $0x100, %rax            # imm = 0x100
movl $0x9b918cc1, %ecx       # imm = 0x9B918CC1
cmovbl %ebp, %ecx
testq %rax, %rax
jne 0x3342d
movl 0x8(%rsp), %ecx
testl %ecx, %ecx
jne 0x33485
xorps %xmm0, %xmm0
leaq 0xb0(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, 0x20(%rdx)
movq $0x0, 0x30(%rdx)
movl $0xe, (%rdx)
movq %r13, 0x8(%rdx)
movl $0x1, 0x10(%rdx)
movups %xmm0, 0x38(%rdx)
movups %xmm0, 0x48(%rdx)
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %r8
movl $0x1, %esi
movq %r12, %rcx
callq 0xfd70
xorl %ebp, %ebp
negl %eax
sbbl %ebp, %ebp
movzwl 0x14(%r14), %edx
leaq 0x108(%rsp), %r13
leaq 0x8(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
movq %r13, %rdi
movq %r12, %rcx
callq 0xfec0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x100, %rcx            # imm = 0x100
movl $0x9b918cc1, %edx       # imm = 0x9B918CC1
cmovbl %eax, %edx
testq %rcx, %rcx
jne 0x334c4
movl 0x8(%rsp), %edx
testl %edx, %edx
jne 0x3351c
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, 0x20(%rdx)
movq $0x0, 0x30(%rdx)
movl $0xe, (%rdx)
movq %r13, 0x8(%rdx)
movl $0x1, 0x10(%rdx)
movups %xmm0, 0x38(%rdx)
movups %xmm0, 0x48(%rdx)
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %r8
movl $0x1, %esi
movq %r12, %rcx
callq 0xfd70
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addl %ebp, %eax
jne 0x3354e
movzwl 0x14(%rsp), %ecx
movl 0x30(%rbx), %edx
xorl %eax, %eax
cmpl %ecx, %edx
seta %al
movzwl 0x34(%rsp), %ecx
xorl %esi, %esi
cmpl %ecx, %edx
seta %sil
subl %esi, %eax
jne 0x3354e
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x107d0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_frame_prepare
static dns_error_t dns_res_frame_prepare(struct dns_resolver *R, struct dns_res_frame *F, const char *qname, enum dns_type qtype, enum dns_class qclass) {
	struct dns_packet *P = NULL;

	if (!(F < endof(R->stack)))
		return DNS_EUNKNOWN;

	dns_p_movptr(&P, &F->query);
	dns_res_frame_reset(R, F);
	dns_p_movptr(&F->query, &P);

	return dns_q_make(&F->query, qname, qtype, qclass, F->qflags);
}

// Assembly:
leaq 0xd38(%rdi), %rax
cmpq %rsi, %rax
jbe 0x335cd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
leaq 0x18(%rsi), %r15
movq 0x18(%rsi), %rax
movq %rax, (%rsp)
movq $0x0, 0x18(%rsi)
movq %rsi, %rdi
callq 0x2ee1c
xorl %ebp, %ebp
movl $0x110, %edx            # imm = 0x110
movq %r12, %rdi
xorl %esi, %esi
callq 0xf750
movq 0x300(%r13), %rax
testq %rax, %rax
je 0x335f6
cmpb $0x0, 0x5c1(%rax)
je 0x335d3
movl $0x2, %ecx
xorl %ebp, %ebp
jmp 0x335e6
movl $0x9b918cc4, %eax       # imm = 0x9B918CC4
retq
movl $0x1, 0xc(%r12)
movl $0x3, %ecx
movl $0x1, %ebp
cmpb $0x1, 0x5b0(%rax)
jne 0x335f6
movl %ecx, 0xc(%r12)
movl %ecx, %ebp
movq (%rsp), %rax
movq %rax, (%r15)
movq %r14, %rdi
callq 0xf560
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl %ebx, %ecx
movl $0x1, %r8d
movl %ebp, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x33297
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/lib/notify.c
// Function: closefd
static int closefd(int *fd) {
	while (*fd >= 0 && 0 != close(*fd)) {
		if (errno != EINTR)
			return errno;
	}

	*fd = -1;

	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rbx), %edi
testl %edi, %edi
js 0x33ea9
callq 0x10a10
testl %eax, %eax
je 0x33ea9
callq 0xf0a0
cmpl $0x4, (%rax)
je 0x33e8e
jmp 0x33eaf
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/lib/notify.c
// Function: notify_timeout
int notify_timeout(struct notify *nfy) {
	if (nfy->dirty || !LIST_EMPTY(&nfy->pending) || !LIST_EMPTY(&nfy->changed))
		return 0;
	else
		return -1;
}

// Assembly:
xorl %eax, %eax
cmpb $0x0, 0x50(%rdi)
jne 0x33ec3
cmpq $0x0, 0x18(%rdi)
je 0x33ec4
retq
xorl %eax, %eax
cmpq $0x1, 0x20(%rdi)
sbbl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/lib/notify.c
// Function: notify_step
int notify_step(struct notify *nfy, int timeout) {
	int error;

	if (nfy->dirty || !LIST_EMPTY(&nfy->pending))
		goto post;

	if (nfy->changes || !LIST_EMPTY(&nfy->changed))
		return 0;

	if ((error = NFY_STEP(nfy, timeout)))
		return error;

post:
	if ((error = NFY_POST(nfy)))
		return error;

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x50(%rdi)
jne 0x33ee1
cmpq $0x0, 0x18(%rbx)
je 0x33f5f
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x33f4c
leaq 0x20(%rbx), %rcx
leaq 0x10(%rbx), %rdx
movq %rax, %rsi
leaq 0x18(%rax), %rdi
movq 0x18(%rax), %rax
movl 0x4(%rsi), %r8d
andl %r8d, 0x8(%rsi)
movq 0x20(%rsi), %r8
je 0x33f22
testq %rax, %rax
je 0x33f14
movq %r8, 0x20(%rax)
movq %rax, (%r8)
movq (%rcx), %r8
movq %r8, (%rdi)
movq %rcx, %r9
jmp 0x33f37
testq %rax, %rax
je 0x33f2b
movq %r8, 0x20(%rax)
movq %rax, (%r8)
movq (%rdx), %r8
movq %r8, (%rdi)
movq %rdx, %r9
testq %r8, %r8
je 0x33f40
movq %rdi, 0x20(%r8)
movq %rsi, (%r9)
movq %r9, 0x20(%rsi)
testq %rax, %rax
jne 0x33ef2
movb $0x0, 0x50(%rbx)
movl 0x48(%rbx), %eax
andl %eax, 0x4c(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
cmpl $0x0, 0x4c(%rbx)
jne 0x33f58
cmpq $0x0, 0x20(%rbx)
jne 0x33f58
movl %esi, %ebp
movq %rbx, %rdi
callq 0x3439d
testl %eax, %eax
je 0x33ee1
cmpl $0xb, %eax
jne 0x33fc4
testl %ebp, %ebp
je 0x33ee1
movl (%rbx), %eax
movq %rsp, %rdi
movl %eax, (%rdi)
movl $0x1, 0x4(%rdi)
movl $0x1, %esi
movl %ebp, %edx
callq 0x10440
cmpl $-0x1, %eax
je 0x33fbd
movq %rbx, %rdi
callq 0x3439d
testl %eax, %eax
jne 0x33fc4
jmp 0x33ee1
callq 0xf0a0
movl (%rax), %eax
cmpl $0xb, %eax
je 0x33ee1
cmpl $0x4, %eax
je 0x33ee1
testl %eax, %eax
jne 0x33f58
jmp 0x33ee1
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/lib/notify.c
// Function: lookup
static struct file *lookup(struct notify *nfy, const char *name, size_t namelen) {
#if ENABLE_FEN
	struct file key = { .name = (char *)name, .namelen = namelen };

	return LLRB_FIND(files, &nfy->files, &key);
#else
	struct file *key = &((union { char pad[offsetof(struct file, name) + NAME_MAX + 1]; struct file file; }){ { 0 } }).file;

	if (namelen > NAME_MAX)
		return NULL;

	memcpy(key->name, name, namelen);
	key->namelen = namelen;

	return LLRB_FIND(files, &nfy->files, key);
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x160, %rsp            # imm = 0x160
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq %rsp, %rdi
xorl %ebx, %ebx
movl $0x160, %edx            # imm = 0x160
xorl %esi, %esi
callq 0xf750
cmpq $0xff, %r15
ja 0x3430d
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xfa60
movq %r15, -0x8(%r14)
movq 0x8(%r12), %rbx
testq %rbx, %rbx
je 0x3430b
leaq 0x60(%rbx), %rsi
movq %r14, %rdi
callq 0x10250
movl $0x38, %ecx
testl %eax, %eax
js 0x34305
movl $0x40, %ecx
je 0x3430d
movq (%rbx,%rcx), %rbx
jmp 0x342e4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x160, %rsp            # imm = 0x160
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/lib/notify.c
// Function: notify_get
int notify_get(struct notify *nfy, const char **name) {
	struct file *file;
	int changes;

	if ((file = LIST_FIRST(&nfy->changed))) {
		NFY_LIST_MOVE(&nfy->dormant, file, le);

		if (name)
			*name = file->name;

		changes = file->changes;
		file->changes = 0;

		return changes;
	}

	if (!nfy->dirty && nfy->changes) {
		if (name)
			*name = ".";

		changes = nfy->changes;
		nfy->changes = 0;

		return changes;
	}

	return 0;
}

// Assembly:
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x34375
movq 0x18(%rcx), %rax
movq 0x20(%rcx), %rdx
testq %rax, %rax
je 0x3433b
movq %rdx, 0x20(%rax)
movq %rax, (%rdx)
movq 0x10(%rdi), %rax
addq $0x10, %rdi
movq %rax, 0x18(%rcx)
testq %rax, %rax
je 0x34357
leaq 0x18(%rcx), %rdx
movq %rdx, 0x20(%rax)
movq %rcx, (%rdi)
movq %rdi, 0x20(%rcx)
testq %rsi, %rsi
je 0x3436a
leaq 0x60(%rcx), %rax
movq %rax, (%rsi)
movl 0x8(%rcx), %eax
movl $0x0, 0x8(%rcx)
retq
xorl %eax, %eax
cmpb $0x0, 0x50(%rdi)
jne 0x3439c
movl 0x4c(%rdi), %ecx
testl %ecx, %ecx
je 0x3439c
testq %rsi, %rsi
je 0x34393
leaq 0x4b83(%rip), %rax      # 0x38f13
movq %rax, (%rsi)
movl $0x0, 0x4c(%rdi)
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ryo[P]shmqueue/shmserver.c
// Function: reap_items
int
reap_items()
{
	int i, nexpire;
	struct keyvalue kv;

	shmqueue_dump(shmqueue);

	nexpire = 0;
	for (i = 0; i < 5000; i++) {
#if 1
		if (!shmqueue_watermark(shmqueue))
			break;
#else
		if (shmqueue_inuse(shmqueue) < 5000)
			break;
#endif

		/* XXX: TODO */

		/* fetch from expire queue, and store to db */
		if (shmqueue_getoldest(shmqueue, &kv) != 0)
			break;

		if ((i & 0xff) == 0) {
			fprintf(stderr, "EXPIRE: key=<%s>, storage_size=%u, storage=<%s>\n",
			    KEYVALUE_KEY(&kv),
			    kv.kv_storagesize,
			    KEYVALUE_STORAGE(&kv));
			fflush(stdout);
		}

		nexpire++;
	}

	fflush(stdout);

	return nexpire;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x7d8, %rsp            # imm = 0x7D8
movq 0x3e23(%rip), %rdi      # 0x50b0
callq 0x1453
leaq 0x8(%rsp), %r14
xorl %ebx, %ebx
leaq 0x4(%rsp), %r15
movq %rsp, %r12
movq 0x3e08(%rip), %rdi      # 0x50b0
callq 0x2677
testl %eax, %eax
je 0x12e9
movq 0x3df8(%rip), %rdi      # 0x50b0
movq %r12, %rsi
callq 0x26b6
testl %eax, %eax
jne 0x12e9
testb %bl, %bl
je 0x12d4
incl %ebx
cmpl $0x1388, %ebx           # imm = 0x1388
jne 0x12a1
jmp 0x12e4
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1140
jmp 0x12c8
movl $0x1388, %ebx           # imm = 0x1388
movq 0x3ce8(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x10e0
movl %ebx, %eax
addq $0x7d8, %rsp            # imm = 0x7D8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/kasymovga[P]devilwm/ewmh.c
// Function: ewmh_set_net_client_list
void ewmh_set_net_client_list(ScreenInfo *s) {
	struct list *iter;
	for (iter = clients_mapping_order; iter; iter = iter->next) {
		Client *c = iter->data;
		XChangeProperty(dpy, s->root, xa_net_client_list,
				XA_WINDOW, 32, PropModeReplace,
				(unsigned char *)&c->window, 1);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x8a2c(%rip), %rax      # 0xe7e8
movq (%rax), %r14
testq %r14, %r14
je 0x5e01
movq %rdi, %rbx
leaq 0x8a5a(%rip), %r15      # 0xe828
movq (%r15), %rdi
movq 0x8(%rbx), %rsi
movq 0x88dc(%rip), %rdx      # 0xe6b8
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x1
pushq 0x8(%r14)
callq 0x3660
addq $0x10, %rsp
movq (%r14), %r14
testq %r14, %r14
jne 0x5dce
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/kasymovga[P]devilwm/ewmh.c
// Function: ewmh_set_net_client_list_stacking
void ewmh_set_net_client_list_stacking(ScreenInfo *s) {
	struct list *iter;
	for (iter = clients_stacking_order; iter; iter = iter->next) {
		Client *c = iter->data;
		if (c->screen == s) {
			XChangeProperty(dpy, s->root, xa_net_client_list_stacking,
					XA_WINDOW, 32, PropModeReplace,
					(unsigned char *)&c->window, 1);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x89dd(%rip), %rax      # 0xe7f0
movq (%rax), %r14
testq %r14, %r14
je 0x5e5f
movq %rdi, %rbx
leaq 0x8a03(%rip), %r15      # 0xe828
movq 0x8(%r14), %rax
cmpq %rbx, 0x10(%rax)
jne 0x5e57
movq (%r15), %rdi
movq 0x8(%rbx), %rsi
movq 0x8883(%rip), %rdx      # 0xe6c0
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x1
pushq %rax
callq 0x3660
addq $0x10, %rsp
movq (%r14), %r14
testq %r14, %r14
jne 0x5e25
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/kasymovga[P]devilwm/screen.c
// Function: find_monitors
void find_monitors(Client *c) {
#ifdef RANDR
	if (have_randr) {
		XRRMonitorInfo *xmonitors = XRRGetMonitors(dpy, c->screen->root, 0, &monitors_count);
		monitors_realloc();
		for (int i = 0; i < monitors_count; i++) {
			monitors[i].x = xmonitors[i].x;
			monitors[i].y = xmonitors[i].y;
			monitors[i].width = xmonitors[i].width;
			monitors[i].height = xmonitors[i].height;
		}
		if (monitors_count) {
			XRRFreeMonitors(xmonitors);
			return;
		}
	}
#endif
	monitors_count = 1;
	monitors_realloc();
	monitors[0].x = 0;
	monitors[0].y = 0;
	monitors[0].width = DisplayWidth(dpy, c->screen->screen);
	monitors[0].height = DisplayHeight(dpy, c->screen->screen);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x71f6(%rip), %rax      # 0xe860
cmpl $0x0, (%rax)
je 0x76e0
leaq 0x71b2(%rip), %rax      # 0xe828
movq (%rax), %rdi
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rsi
leaq 0x71f8(%rip), %rcx      # 0xe880
xorl %edx, %edx
callq 0x3170
movq %rax, %r14
callq 0x772a
movl 0x71e3(%rip), %eax      # 0xe880
testl %eax, %eax
jle 0x76cd
movq 0x71d0(%rip), %rcx      # 0xe878
movl 0x71d2(%rip), %eax      # 0xe880
movslq %eax, %rdx
leaq 0x14(%r14), %rsi
xorl %edi, %edi
movups (%rsi), %xmm0
movups %xmm0, (%rcx)
incq %rdi
addq $0x38, %rsi
addq $0x10, %rcx
cmpq %rdx, %rdi
jl 0x76b7
testl %eax, %eax
je 0x76e0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x32e0
movl $0x1, 0x7196(%rip)      # 0xe880
callq 0x772a
movq 0x7182(%rip), %rax      # 0xe878
movq $0x0, (%rax)
leaq 0x7124(%rip), %rcx      # 0xe828
movq (%rcx), %rcx
movq 0xe8(%rcx), %rcx
movq 0x10(%rbx), %rdx
movslq (%rdx), %rdx
shlq $0x7, %rdx
movq 0x18(%rcx,%rdx), %rcx
movq %rcx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/kasymovga[P]devilwm/screen.c
// Function: monitors_realloc
static void monitors_realloc(void) {
	static Monitor monitor_static;
	if (!monitors_count)
		return;

	if (monitors_size < monitors_count) {
		if (monitors != &monitor_static) {
			free(monitors);
		}
		monitors = malloc(sizeof(struct Monitor) * monitors_count);
		if (monitors)
			monitors_size = monitors_count;
		else {
			monitors_size = 0;
		}
	}
	if (monitors) {
		return;
	}
	//Canot allocate memory
	LOG_ERROR("out of memory\n");
	monitors_count = 1;
	monitors = &monitor_static;
}

// Assembly:
pushq %rbx
movl 0x714f(%rip), %ebx      # 0xe880
testl %ebx, %ebx
je 0x7780
movq 0x713c(%rip), %rdi      # 0xe878
cmpl %ebx, 0x7142(%rip)      # 0xe884
jge 0x777b
leaq 0x713d(%rip), %rax      # 0xe888
cmpq %rax, %rdi
je 0x775b
callq 0x32b0
movl 0x7125(%rip), %ebx      # 0xe880
movslq %ebx, %rdi
shlq $0x4, %rdi
callq 0x31c0
movq %rax, 0x710a(%rip)      # 0xe878
testq %rax, %rax
je 0x7782
movl %ebx, 0x710b(%rip)      # 0xe884
jmp 0x7780
testq %rdi, %rdi
je 0x778c
popq %rbx
retq
movl $0x0, 0x70f8(%rip)      # 0xe884
callq 0x390c
jmp 0x7780
// File: /workspace/github_c_makefile_star2_O3/kasymovga[P]devilwm/screen.c
// Function: find_monitor
Monitor *find_monitor(Client *c) {
	find_monitors(c);
	for (int i = 0; i < monitors_count; i++) {
		if (monitors[i].x + monitors[i].width < c->x
				|| monitors[i].x >= c->x + c->width
				|| monitors[i].y >= c->y + c->height
				|| monitors[i].y + monitors[i].width < c->y)
			continue;

		return &monitors[i];
	}
	return &monitors[0];
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x765c
movslq 0x70da(%rip), %rcx      # 0xe880
movq 0x70cb(%rip), %rax      # 0xe878
testq %rcx, %rcx
jle 0x782e
movl 0x24(%rbx), %edx
movq %rcx, %rsi
negq %rsi
movb $0x1, %dil
movl $0x1, %r8d
movq %rax, %r10
movq %r10, %r9
movl (%r10), %r11d
movl 0x8(%r10), %r10d
leal (%r10,%r11), %ebp
cmpl %edx, %ebp
jl 0x780b
movl 0x2c(%rbx), %ebp
addl %edx, %ebp
cmpl %ebp, %r11d
jge 0x780b
movl 0x4(%r9), %r11d
movl 0x28(%rbx), %ebp
movl 0x30(%rbx), %r14d
addl %ebp, %r14d
cmpl %r14d, %r11d
setge %r14b
addl %r11d, %r10d
cmpl %ebp, %r10d
setl %r10b
orb %r14b, %r10b
cmpb $0x1, %r10b
jne 0x7826
cmpq %rcx, %r8
setb %dil
leaq 0x10(%r9), %r10
leaq (%rsi,%r8), %r11
incq %r11
incq %r8
cmpq $0x1, %r11
jne 0x77c7
testb $0x1, %dil
cmovneq %r9, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kasymovga[P]devilwm/screen.c
// Function: next
void next(void) {
	struct list *newl = list_find(clients_tab_order, current);
	ScreenInfo *current_screen = find_current_screen();
	Client *newc = current;
	if (newl)
		newc = next_find(newl->next, NULL, current_screen);

	if (!newc)
		newc = next_find(clients_tab_order, newl, current_screen);

	select_client(newc);
	if (!newc)
		return;

	client_show(newc);
	//client_raise(newc);
#ifdef WARP_POINTER
	setmouse(newc->window, newc->width + newc->border - 1,
			newc->height + newc->border - 1);
#endif
	discard_enter_events(newc);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x5db2(%rip), %r12      # 0xe7e0
movq (%r12), %rdi
leaq 0x5dbf(%rip), %r14      # 0xe7f8
movq (%r14), %rsi
callq 0x6242
movq %rax, %rbx
callq 0x8abb
movq %rax, %r15
testq %rbx, %rbx
je 0x8a63
movq (%rbx), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x8b2f
movq %rax, %r14
jmp 0x8a66
movq (%r14), %r14
testq %r14, %r14
je 0x8a75
movq %r14, %rdi
callq 0x3ccb
jmp 0x8a94
movq (%r12), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x8b2f
movq %rax, %r14
movq %rax, %rdi
callq 0x3ccb
testq %r14, %r14
je 0x8aaf
movq %r14, %rdi
callq 0x3b05
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6c6d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/kasymovga[P]devilwm/screen.c
// Function: next_find
static Client *next_find(struct list *start, struct list *end, ScreenInfo *screen) {
	struct Client *c;
	for (struct list *l = start; l; l = l->next) {
		c = l->data;
		if (c->screen == screen && ((!c->is_dock || c->screen->docks_visible)
#ifdef VWM
				&& (is_fixed(c) || c->vdesk == c->screen->vdesk)
#endif
		))
			return c;

		if (l == end)
			return NULL;
	}
	return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x8b67
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rcx
cmpq %rdx, %rcx
jne 0x8b5d
cmpl $0x0, 0x7c(%rax)
je 0x8b4d
cmpl $0x0, 0x68(%rcx)
je 0x8b5d
movl 0x78(%rax), %r8d
cmpl $-0x1, %r8d
je 0x8b69
cmpl 0x40(%rcx), %r8d
je 0x8b69
cmpq %rsi, %rdi
je 0x8b67
movq (%rdi), %rdi
jmp 0x8b2f
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]hash-prospector/prospector.c
// Function: usage
static void
usage(FILE *f)
{
    fprintf(f, "usage: prospector "
            "[-E|L|S] [-4|-8] [-ehs] [-l lib] [-p pattern] [-r n:m] [-t x]\n");
    fprintf(f, " -4          Generate 32-bit hash functions (default)\n");
    fprintf(f, " -8          Generate 64-bit hash functions\n");
    fprintf(f, " -e          Measure bias exactly (requires -E)\n");
    fprintf(f, " -h          Print this help message\n");
    fprintf(f, " -l ./lib.so Load hash() from a shared object\n");
    fprintf(f, " -p pattern  Search only a given pattern\n");
    fprintf(f, " -q n        Score quality knob (12-30, default: 18)\n");
    fprintf(f, " -r n:m      Use between n and m operations [3:6]\n");
    fprintf(f, " -s          Don't use large constants\n");
    fprintf(f, " -t x        Initial score threshold [10.0]\n");
    fprintf(f, " -E          Single evaluation mode (requires -p or -l)\n");
    fprintf(f, " -S          Hash function search mode (default)\n");
    fprintf(f, " -L          Enumerate output mode (requires -p or -l)\n");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x13a8(%rip), %rdi      # 0x33da
movl $0x50, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11c0
leaq 0x13e0(%rip), %rdi      # 0x342b
movl $0x36, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11c0
leaq 0x13fe(%rip), %rdi      # 0x3462
movl $0x2c, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11c0
leaq 0x1412(%rip), %rdi      # 0x348f
movl $0x30, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11c0
leaq 0x142a(%rip), %rdi      # 0x34c0
movl $0x25, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11c0
leaq 0x1437(%rip), %rdi      # 0x34e6
movl $0x2e, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11c0
leaq 0x144d(%rip), %rdi      # 0x3515
movl $0x29, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11c0
leaq 0x145e(%rip), %rdi      # 0x353f
movl $0x35, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11c0
leaq 0x147b(%rip), %rdi      # 0x3575
movl $0x32, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11c0
leaq 0x1495(%rip), %rdi      # 0x35a8
movl $0x27, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11c0
leaq 0x14a4(%rip), %rdi      # 0x35d0
movl $0x2c, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11c0
leaq 0x14b8(%rip), %rdi      # 0x35fd
movl $0x38, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11c0
leaq 0x14d8(%rip), %rdi      # 0x3636
movl $0x31, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11c0
leaq 0x14f1(%rip), %rdi      # 0x3668
movl $0x37, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
jmp 0x11c0
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]hash-prospector/prospector.c
// Function: execbuf_lock
static void
execbuf_lock(void *buf)
{
    switch (wxr_enabled) {
        case WXR_UNKNOWN:
            if (!mprotect(buf, 4096, PROT_READ | PROT_WRITE | PROT_EXEC)) {
                wxr_enabled = WXR_DISABLED;
                return;
            }
            wxr_enabled = WXR_ENABLED;
            /* FALLTHROUGH */
        case WXR_ENABLED:
            if (mprotect(buf, 4096, PROT_READ | PROT_EXEC)) {
                fprintf(stderr,
                        "prospector: mprotect(PROT_EXEC) failed: %s\n",
                        strerror(errno));
                exit(EXIT_FAILURE);
            }
            break;
        case WXR_DISABLED:
            break;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x2c68(%rip), %eax      # 0x5110
cmpl $0x1, %eax
je 0x24d1
testl %eax, %eax
jne 0x24e7
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
movl $0x7, %edx
callq 0x1140
testl %eax, %eax
je 0x24e9
movl $0x1, 0x2c3f(%rip)      # 0x5110
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
movl $0x5, %edx
callq 0x1140
testl %eax, %eax
jne 0x24f5
popq %rbx
retq
movl $0x2, 0x2c1d(%rip)      # 0x5110
jmp 0x24e7
callq 0x132c
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]hash-prospector/prospector.c
// Function: load_function
static void *
load_function(const char *so)
{
    void *handle = dlopen(so, RTLD_NOW);
    if (!handle) {
        fprintf(stderr, "prospector: could not load %s\n", so);
        exit(EXIT_FAILURE);
    }
    void *f = dlsym(handle, "hash");
    if (!f) {
        fprintf(stderr, "prospector: could not find 'hash' in %s\n", so);
        exit(EXIT_FAILURE);
    }
    return f;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, %esi
callq 0x1100
testq %rax, %rax
je 0x2523
leaq 0x11d9(%rip), %rsi      # 0x36ed
movq %rax, %rdi
callq 0x1180
testq %rax, %rax
je 0x252b
popq %rbx
retq
movq %rbx, %rdi
callq 0x1383
movq %rbx, %rdi
callq 0x135f
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]hash-prospector/prospector.c
// Function: estimate_bias32
static double
estimate_bias32(uint32_t ABI (*f)(uint32_t), uint64_t rng[2])
{
    long n = 1L << score_quality;
    long bins[32][32] = {{0}};
    for (long i = 0; i < n; i++) {
        uint32_t x = xoroshiro128plus(rng);
        uint32_t h0 = f(x);
        for (int j = 0; j < 32; j++) {
            uint32_t bit = UINT32_C(1) << j;
            uint32_t h1 = f(x ^ bit);
            uint32_t set = h0 ^ h1;
            for (int k = 0; k < 32; k++)
                bins[j][k] += (set >> k) & 1;
        }
    }
    double mean = 0;
    for (int j = 0; j < 32; j++) {
        for (int k = 0; k < 32; k++) {
            /* FIXME: normalize this somehow */
            double diff = (bins[j][k] - n / 2) / (n / 2.0);
            mean += (diff * diff) / (32 * 32);
        }
    }
    return sqrt(mean) * 1000.0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movq %rsi, 0x18(%rsp)
movq %rdi, %r14
movl 0x29ea(%rip), %ebp      # 0x5108
movl $0x1, %eax
movq %rax, 0x8(%rsp)
movl %ebp, %ecx
shlq %cl, %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x2000, %edx           # imm = 0x2000
xorl %esi, %esi
callq 0x10c0
cmpl $0x3f, %ebp
je 0x27dc
movq 0x10(%rsp), %rax
cmpq $0x2, %rax
movq 0x8(%rsp), %rcx
cmovgeq %rax, %rcx
movq %rcx, 0x8(%rsp)
xorl %r15d, %r15d
movq 0x18(%rsp), %rsi
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
leal (%rcx,%rax), %ebp
xorq %rax, %rcx
rolq $0x18, %rax
movq %rcx, %rdx
shlq $0x10, %rdx
xorq %rax, %rdx
xorq %rcx, %rdx
movq %rdx, (%rsi)
rolq $0x25, %rcx
movq %rcx, 0x8(%rsi)
movl %ebp, %edi
callq *%r14
movl %eax, %r12d
leaq 0x20(%rsp), %r13
xorl %ebx, %ebx
movl %ebp, %edi
btcl %ebx, %edi
callq *%r14
xorl %r12d, %eax
xorl %ecx, %ecx
btl %ecx, %eax
adcq $0x0, (%r13,%rcx,8)
incq %rcx
cmpq $0x20, %rcx
jne 0x27b0
incq %rbx
addq $0x100, %r13            # imm = 0x100
cmpq $0x20, %rbx
jne 0x27a3
incq %r15
cmpq 0x8(%rsp), %r15
jne 0x2766
movq 0x10(%rsp), %rcx
movq %rcx, %rax
shrq $0x3f, %rax
addq %rcx, %rax
sarq %rax
negq %rax
cvtsi2sd %rcx, %xmm1
mulsd 0x82a(%rip), %xmm1      # 0x3028
xorpd %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
xorl %edx, %edx
movsd 0x807(%rip), %xmm2      # 0x3018
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
addq %rax, %rdi
xorps %xmm3, %xmm3
cvtsi2sd %rdi, %xmm3
divsd %xmm1, %xmm3
mulsd %xmm3, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
incq %rsi
cmpq $0x20, %rsi
jne 0x2813
incq %rdx
addq $0x100, %rcx            # imm = 0x100
cmpq $0x20, %rdx
jne 0x2811
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x285b
sqrtsd %xmm0, %xmm0
jmp 0x2860
callq 0x11d0
mulsd 0x7b8(%rip), %xmm0      # 0x3020
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]hash-prospector/prospector.c
// Function: hf_randomize
static void
hf_randomize(struct hf_op *op, uint64_t s[2])
{
    uint64_t r = xoroshiro128plus(s);
    switch (op->type) {
        case HF32_NOT:
        case HF64_NOT:
        case HF32_BSWAP:
        case HF64_BSWAP:
            op->constant = 0;
            break;
        case HF32_XOR:
        case HF32_ADD:
            op->constant = (uint32_t)r;
            break;
        case HF32_MUL:
            op->constant = (uint32_t)r | 1;
            break;
        case HF32_ROT:
        case HF32_XORL:
        case HF32_XORR:
        case HF32_ADDL:
        case HF32_SUBL:
            op->constant = 1 + r % 31;
            break;
        case HF64_XOR:
        case HF64_ADD:
            op->constant = r;
            break;
        case HF64_MUL:
            op->constant = r | 1;
            break;
        case HF64_ROT:
        case HF64_XORL:
        case HF64_XORR:
        case HF64_ADDL:
        case HF64_SUBL:
            op->constant = 1 + r % 63;
            break;
    }
}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, %rdx
xorq %rax, %rdx
movq %rax, %r8
rolq $0x18, %r8
movq %rdx, %r9
shlq $0x10, %r9
xorq %r8, %r9
xorq %rdx, %r9
rolq $0x25, %rdx
movq %r9, (%rsi)
movq %rdx, 0x8(%rsi)
movl (%rdi), %edx
cmpq $0x13, %rdx
ja 0x2935
addq %rax, %rcx
leaq 0x8c4(%rip), %rax       # 0x3180
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movabsq $0x842108421084211, %rdx # imm = 0x842108421084211
movq %rcx, %rax
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x4, %rax
movq %rax, %rdx
shlq $0x5, %rdx
jmp 0x2915
movabsq $0x410410410410411, %rdx # imm = 0x410410410410411
movq %rcx, %rax
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x5, %rax
movq %rax, %rdx
shlq $0x6, %rdx
subq %rdx, %rax
addq %rax, %rcx
incq %rcx
jmp 0x2931
xorl %ecx, %ecx
jmp 0x2931
movl %ecx, %ecx
jmp 0x2931
orq $0x1, %rcx
jmp 0x2931
orl $0x1, %ecx
movq %rcx, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./imgp.h
// Function: imgp_gray
void imgp_gray(uint8_t *s, int sx, int sy, int stride, uint8_t *p, int gstride)
{
	for (int y=0; y<sy; y++) {
		for (int x=0; x<sx; x++) {
			p[x] = 0.3 * s[x*3+0] + 0.59 * s[x*3+1] + 0.11*s[x*3+2];
		}

		s += stride*3;
		p += gstride;
	}
}

// Assembly:
testl %edx, %edx
jle 0x7204
pushq %rbp
pushq %rbx
leal (%rcx,%rcx,2), %eax
cltq
movslq %r9d, %rcx
movl %esi, %r9d
addq $0x2, %rdi
xorl %r10d, %r10d
movsd 0x199e0(%rip), %xmm0    # 0x20b70
movsd 0x199e0(%rip), %xmm1    # 0x20b78
movsd 0x199e0(%rip), %xmm2    # 0x20b80
testl %esi, %esi
jle 0x71f4
movq %rdi, %r11
xorl %ebx, %ebx
movzbl -0x2(%r11), %ebp
xorps %xmm3, %xmm3
cvtsi2sd %ebp, %xmm3
movzbl -0x1(%r11), %ebp
xorps %xmm4, %xmm4
cvtsi2sd %ebp, %xmm4
mulsd %xmm0, %xmm4
mulsd %xmm1, %xmm3
addsd %xmm4, %xmm3
movzbl (%r11), %ebp
xorps %xmm4, %xmm4
cvtsi2sd %ebp, %xmm4
mulsd %xmm2, %xmm4
addsd %xmm3, %xmm4
cvttsd2si %xmm4, %ebp
movb %bpl, (%r8,%rbx)
incq %rbx
addq $0x3, %r11
cmpq %rbx, %r9
jne 0x71a9
addq %rcx, %r8
incl %r10d
addq %rax, %rdi
cmpl %edx, %r10d
jne 0x71a0
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./imgp.h
// Function: imgp_dilate
void imgp_dilate(uint8_t *s, int w, int h, int bpp, uint8_t *p)
{
	for (int y=1; y<h-1; y++) {
		for (int x=1; x<w-1; x++) {
			for (int b=0; b<bpp; b++) {
				uint8_t uc = s[ ((y+0)*w + (x+0))*bpp+b ]; // centre
				uint8_t ua = s[ ((y-1)*w + (x+0))*bpp+b ]; // above
				uint8_t ub = s[ ((y+1)*w + (x+0))*bpp+b ]; // below
				uint8_t ul = s[ ((y+0)*w + (x-1))*bpp+b ]; // left
				uint8_t ur = s[ ((y+0)*w + (x+1))*bpp+b ]; // right

				uint8_t ux = 0;
				if (uc > ux) ux = uc;
				if (ua > ux) ux = ua;
				if (ub > ux) ux = ub;
				if (ul > ux) ux = ul;
				if (ur > ux) ux = ur;
				p[ (y*w + x)*bpp+b ] = ux;
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, -0x18(%rsp)
movq %rdi, -0x40(%rsp)
cmpl $0x3, %edx
jl 0x736c
decl %edx
leal -0x1(%rsi), %eax
movq %rax, -0x8(%rsp)
movslq %ecx, %rax
movslq %esi, %rdi
movq %rdi, -0x30(%rsp)
movq %rax, -0x38(%rsp)
movl %eax, %r11d
movl %ecx, %eax
imull %esi, %eax
movl %eax, -0x48(%rsp)
movl $0x1, %r14d
movl %ecx, -0x44(%rsp)
movq %rdx, -0x20(%rsp)
movq %rsi, -0x28(%rsp)
cmpl $0x2, %esi
jle 0x735d
movq %r14, %r12
movq -0x30(%rsp), %rax
imulq %rax, %r12
leaq -0x1(%r14), %r13
imulq %rax, %r13
leaq 0x1(%r14), %rbp
movq %rbp, -0x10(%rsp)
imulq %rax, %rbp
leal 0x2(%r12), %ebx
imull %ecx, %ebx
imull -0x48(%rsp), %r14d
incq %rbp
movq -0x38(%rsp), %rax
imulq %rax, %rbp
movq -0x40(%rsp), %rdx
addq %rdx, %rbp
incq %r13
imulq %rax, %r13
addq %rdx, %r13
incq %r12
imulq %rax, %r12
movq -0x18(%rsp), %rax
leaq (%rax,%r12), %r8
addq %rdx, %r12
movl $0x1, %r10d
testl %ecx, %ecx
jle 0x7325
movslq %ebx, %rsi
movq -0x40(%rsp), %rax
addq %rax, %rsi
movslq %r14d, %rdx
addq %rax, %rdx
xorl %r15d, %r15d
movzbl (%r12,%r15), %eax
movzbl (%r13,%r15), %edi
movzbl (%rbp,%r15), %ecx
movzbl (%rdx,%r15), %r9d
cmpb %al, %dil
cmoval %edi, %eax
cmpb %al, %cl
cmoval %ecx, %eax
cmpb %al, %r9b
ja 0x730c
movl %eax, %r9d
movzbl (%rsi,%r15), %eax
cmpb %r9b, %al
ja 0x7319
movl %r9d, %eax
movb %al, (%r8,%r15)
incq %r15
cmpq %r15, %r11
jne 0x72e3
incq %r10
movl -0x44(%rsp), %ecx
addl %ecx, %ebx
addl %ecx, %r14d
movq -0x38(%rsp), %rax
addq %rax, %rbp
addq %rax, %r13
addq %rax, %r8
addq %rax, %r12
cmpq -0x8(%rsp), %r10
jne 0x72cb
movq -0x10(%rsp), %rax
movq %rax, %r14
movq -0x20(%rsp), %rdx
movq -0x28(%rsp), %rsi
jmp 0x7363
incq %r14
movq %r14, %rax
cmpq %rdx, %rax
jne 0x725c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./imgp.h
// Function: imgp_ahash
void imgp_ahash(uint8_t *s, int w, int h, uint8_t *ahash)
{
	uint8_t resize[AHASH_SIZE*AHASH_SIZE];
	stbir_resize_uint8(s, w, h, 0, resize, AHASH_SIZE, AHASH_SIZE, 0, 1);

	double avg = 0;
	for (int i=0; i<AHASH_SIZE*AHASH_SIZE; i++) {
		avg += resize[i];
	}
	avg /= AHASH_SIZE*AHASH_SIZE;
	//printf("avg: %f\n", avg);

	for (int i=0; i<AHASH_SIZE*AHASH_SIZE; i++) {
		ahash[i/8] <<= 1;
		if (avg <= (double)resize[i]) ahash[i/8] |= 1;
		else ahash[i/8] &= ~1;
	}

	/*for (int i=0; i<AHASH_SIZE*AHASH_SIZE/8; i++) {
		printf("%02x", ahash[i]);
	}
	printf("\n");*/
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rcx, %rbx
xorl %r14d, %r14d
movl $0x1, %eax
movq %rsp, %r8
movss 0x16c26(%rip), %xmm2    # 0x1e008
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
movl $0x10, %r9d
movaps %xmm2, %xmm3
pushq %r14
pushq %rax
pushq %rax
pushq %r14
pushq %r14
pushq %r14
pushq %r14
pushq $-0x1
pushq %rax
pushq $0x0
pushq %r14
pushq $0x10
callq 0x5aea
addq $0x60, %rsp
xorpd %xmm0, %xmm0
movzbl (%rsp,%r14), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
addsd %xmm1, %xmm0
incq %r14
cmpq $0x100, %r14            # imm = 0x100
jne 0x7417
mulsd 0x1974d(%rip), %xmm0    # 0x20b88
xorl %eax, %eax
movl %eax, %ecx
shrl $0x3, %ecx
movb (%rbx,%rcx), %dl
movzbl (%rsp,%rax), %esi
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
addb %dl, %dl
ucomisd %xmm0, %xmm1
setae %sil
orb %dl, %sil
movb %sil, (%rbx,%rcx)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x743d
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./imgp.h
// Function: cmp_node
int cmp_node(oct_node a, oct_node b)
{
	if (a->n_kids < b->n_kids) return -1;
	if (a->n_kids > b->n_kids) return 1;

	int ac = a->count * (1 + a->kid_idx) >> a->depth;
	int bc = b->count * (1 + b->kid_idx) >> b->depth;
	return ac < bc ? -1 : ac > bc;
}

// Assembly:
movb 0x68(%rsi), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb %cl, 0x68(%rdi)
jb 0x7743
movl $0x1, %eax
ja 0x7743
movzbl 0x69(%rdi), %eax
incl %eax
imull 0x18(%rdi), %eax
movb 0x6b(%rdi), %cl
sarl %cl, %eax
movzbl 0x69(%rsi), %edx
incl %edx
imull 0x18(%rsi), %edx
movb 0x6b(%rsi), %cl
sarl %cl, %edx
xorl %ecx, %ecx
cmpl %edx, %eax
setg %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovgel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./imgp.h
// Function: down_heap
void down_heap(node_heap *h, oct_node p)
{
	int n = p->heap_idx, m;
	while (1) {
		m = n * 2;
		if (m >= h->n) break;
		if (m + 1 < h->n && cmp_node(h->buf[m], h->buf[m + 1]) > 0) m++;

		if (cmp_node(p, h->buf[m]) <= 0) break;

		h->buf[n] = h->buf[m];
		h->buf[n]->heap_idx = n;
		n = m;
	}
	h->buf[n] = p;
	p->heap_idx = n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movl 0x1c(%rsi), %ebx
movl 0x4(%rdi), %ebp
leal (%rbx,%rbx), %r15d
movq 0x8(%rdi), %r12
cmpl %ebp, %r15d
jge 0x77ca
movq %rdi, %r14
movl %r15d, %r13d
orl $0x1, %r13d
cmpl %ebp, %r13d
jge 0x778c
movslq %r15d, %rax
movq (%r12,%rax,8), %rdi
movslq %r13d, %rax
movq (%r12,%rax,8), %rsi
callq 0x7702
testl %eax, %eax
jg 0x778f
movl %r15d, %r13d
movslq %r13d, %rax
movq (%r12,%rax,8), %r15
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x7702
testl %eax, %eax
jle 0x77ca
movslq %ebx, %rax
movq %r15, (%r12,%rax,8)
movq 0x8(%r14), %r12
movq (%r12,%rax,8), %rcx
movl %eax, 0x1c(%rcx)
leal (,%r13,2), %r15d
movl %r13d, %ebx
cmpl %ebp, %r15d
jl 0x7769
jmp 0x77cd
movl %ebx, %r13d
movslq %r13d, %rax
movq (%rsp), %rcx
movq %rcx, (%r12,%rax,8)
movl %eax, 0x1c(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./imgp.h
// Function: up_heap
void up_heap(node_heap *h, oct_node p)
{
	int n = p->heap_idx;
	oct_node prev;

	while (n>1) {
		prev = h->buf[n / 2];
		if (cmp_node(p, prev) >= 0) break;

		h->buf[n] = prev;
		prev->heap_idx = n;
		n /= 2;
	}
	h->buf[n] = p;
	p->heap_idx = n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x1c(%rsi), %ebp
cmpl $0x2, %ebp
jl 0x7836
movl %ebp, %r12d
movq 0x8(%r14), %r13
shrl %r12d
movq (%r13,%r12,8), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7702
testl %eax, %eax
jns 0x7836
movl %ebp, %eax
movq %r15, (%r13,%rax,8)
movl %ebp, 0x1c(%r15)
cmpl $0x3, %ebp
movl %r12d, %ebp
ja 0x7806
jmp 0x7839
movl %ebp, %r12d
movq 0x8(%r14), %rax
movslq %r12d, %rcx
movq %rbx, (%rax,%rcx,8)
movl %ecx, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./imgp.h
// Function: heap_add
void heap_add(node_heap *h, oct_node p)
{
	if ((p->flags & ON_INHEAP)) {
		down_heap(h, p);
		up_heap(h, p);
		return;
	}

	p->flags |= ON_INHEAP;
	if (!h->n) h->n = 1;
	if (h->n >= h->alloc) {
		while (h->n >= h->alloc) h->alloc += 1024;
		h->buf = realloc(h->buf, sizeof(oct_node) * h->alloc);
	}

	p->heap_idx = h->n;
	h->buf[h->n++] = p;
	up_heap(h, p);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb 0x6a(%rsi), %al
testb $0x1, %al
jne 0x788e
orb $0x1, %al
movb %al, 0x6a(%rbx)
movl 0x4(%r14), %ecx
testl %ecx, %ecx
jne 0x7881
movl $0x1, 0x4(%r14)
movl $0x1, %ecx
movl (%r14), %eax
cmpl %eax, %ecx
jge 0x789b
movq 0x8(%r14), %rax
jmp 0x78d6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7744
jmp 0x78e7
leal 0x400(%rax), %edx
incl %ecx
cmpl %ecx, %edx
cmovgl %edx, %ecx
movl %eax, %edx
notl %edx
addl %ecx, %edx
andl $0xfffffc00, %edx       # imm = 0xFFFFFC00
addl %edx, %eax
addl $0x400, %eax            # imm = 0x400
movl %eax, (%r14)
movq 0x8(%r14), %rdi
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x11b0
movq %rax, 0x8(%r14)
movl 0x4(%r14), %ecx
movl %ecx, 0x1c(%rbx)
leal 0x1(%rcx), %edx
movl %edx, 0x4(%r14)
movslq %ecx, %rcx
movq %rbx, (%rax,%rcx,8)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x77ea
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./imgp.h
// Function: pop_heap
oct_node pop_heap(node_heap *h)
{
	if (h->n <= 1) return 0;

	oct_node ret = h->buf[1];
	h->buf[1] = h->buf[--h->n];

	h->buf[h->n] = 0;

	h->buf[1]->heap_idx = 1;
	down_heap(h, h->buf[1]);

	return ret;
}

// Assembly:
pushq %rbx
movl 0x4(%rdi), %eax
cmpl $0x2, %eax
jge 0x7906
xorl %ebx, %ebx
jmp 0x793b
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rbx
decl %eax
movl %eax, 0x4(%rdi)
movq (%rcx,%rax,8), %rdx
movq %rdx, 0x8(%rcx)
movq 0x8(%rdi), %rcx
movq $0x0, (%rcx,%rax,8)
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rsi
movl $0x1, 0x1c(%rsi)
callq 0x7744
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./imgp.h
// Function: node_new
oct_node node_new(unsigned char idx, unsigned char depth, oct_node p)
{
	static int len = 0;
	if (len <= 1) {
		oct_node p = calloc(sizeof(oct_node_t), 2048);
		p->parent = oct_pool;
		oct_pool = p;
		len = 2047;
	}

	oct_node x = oct_pool + len--;
	x->kid_idx = idx;
	x->depth = depth;
	x->parent = p;
	if (p) p->n_kids++;
	return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
movl 0x208c3(%rip), %ecx     # 0x28218
movq 0x208c4(%rip), %r15     # 0x28220
cmpl $0x1, %ecx
jg 0x7983
movl $0x70, %edi
movl $0x800, %esi            # imm = 0x800
callq 0x1110
movq %r15, 0x60(%rax)
movq %rax, 0x208a5(%rip)     # 0x28220
movl $0x7ff, %ecx            # imm = 0x7FF
movq %rax, %r15
leal -0x1(%rcx), %eax
movl %eax, 0x2088c(%rip)     # 0x28218
movl %ecx, %eax
imulq $0x70, %rax, %rcx
leaq (%r15,%rcx), %rax
movb %r14b, 0x69(%r15,%rcx)
movb %bpl, 0x6b(%r15,%rcx)
movq %rbx, 0x60(%r15,%rcx)
testq %rbx, %rbx
je 0x79ad
incb 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./imgp.h
// Function: node_free
void node_free()
{
	oct_node p;
	while (oct_pool) {
		p = oct_pool->parent;
		free(oct_pool);
		oct_pool = p;
	}
}

// Assembly:
movq 0x20861(%rip), %rdi     # 0x28220
testq %rdi, %rdi
je 0x79de
pushq %rbx
movq 0x60(%rdi), %rbx
callq 0x1030
movq %rbx, 0x2084b(%rip)     # 0x28220
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x79c5
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./imgp.h
// Function: node_insert
oct_node node_insert(oct_node root, unsigned char *pix)
{
	unsigned char i, bit, depth = 0;
	for (bit = 1 << 7; ++depth < OCT_DEPTH; bit >>= 1) {
		i = !!(pix[1] & bit) * 4 + !!(pix[0] & bit) * 2 + !!(pix[2] & bit);
		if (!root->kids[i]) {
			root->kids[i] = node_new(i, depth, root);
		}

		root = root->kids[i];
	}

	root->r += pix[0];
	root->g += pix[1];
	root->b += pix[2];
	root->count++;
	return root;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x80, %ebp
movb $0x1, %r12b
movzbl 0x1(%rbx), %eax
testl %eax, %ebp
setne %al
shlb $0x2, %al
movzbl (%rbx), %ecx
testl %ecx, %ebp
setne %cl
addb %cl, %cl
orb %al, %cl
movzbl 0x2(%rbx), %eax
testl %eax, %ebp
setne %al
orb %cl, %al
movzbl %al, %r15d
movq 0x20(%r14,%r15,8), %rax
testq %rax, %rax
jne 0x7a3a
movzbl %r12b, %esi
movl %r15d, %edi
movq %r14, %rdx
callq 0x7940
movq %rax, 0x20(%r14,%r15,8)
shrl %ebp
incb %r12b
movq %rax, %r14
cmpb $0x8, %r12b
jne 0x79f5
movzbl (%rbx), %ecx
addq %rcx, (%rax)
movzbl 0x1(%rbx), %ecx
addq %rcx, 0x8(%rax)
movzbl 0x2(%rbx), %ecx
addq %rcx, 0x10(%rax)
incl 0x18(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./imgp.h
// Function: node_fold
oct_node node_fold(oct_node p)
{
	if (p->n_kids) abort();
	oct_node q = p->parent;
	q->count += p->count;

	q->r += p->r;
	q->g += p->g;
	q->b += p->b;
	q->n_kids --;
	q->kids[p->kid_idx] = 0;
	return q;
}

// Assembly:
cmpb $0x0, 0x68(%rdi)
jne 0x7aa3
movq 0x60(%rdi), %rax
movl 0x18(%rdi), %ecx
addl %ecx, 0x18(%rax)
movdqu (%rdi), %xmm0
movdqu (%rax), %xmm1
paddq %xmm0, %xmm1
movdqu %xmm1, (%rax)
movq 0x10(%rdi), %rcx
addq %rcx, 0x10(%rax)
decb 0x68(%rax)
movzbl 0x69(%rdi), %ecx
movq $0x0, 0x20(%rax,%rcx,8)
retq
pushq %rax
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./imgp.h
// Function: color_replace
void color_replace(oct_node root, unsigned char *pix)
{
	unsigned char i, bit;

	for (bit = 1 << 7; bit; bit >>= 1) {
		i = !!(pix[1] & bit) * 4 + !!(pix[0] & bit) * 2 + !!(pix[2] & bit);
		if (!root->kids[i]) break;
		root = root->kids[i];
	}

	pix[0] = root->r;
	pix[1] = root->g;
	pix[2] = root->b;
}

// Assembly:
movb (%rsi), %al
movb 0x1(%rsi), %cl
movb 0x2(%rsi), %dl
movb $-0x80, %r8b
movq %rdi, %r9
xorl %edi, %edi
testb %r8b, %cl
setne %dil
xorl %r10d, %r10d
testb %r8b, %al
setne %r10b
shll $0x2, %edi
leal (%rdi,%r10,2), %edi
xorl %r10d, %r10d
testb %r8b, %dl
setne %r10b
orl %edi, %r10d
movq 0x20(%r9,%r10,8), %rdi
testq %rdi, %rdi
je 0x7afa
movl %r8d, %r10d
shrb %r10b
movq %rdi, %r9
cmpb $0x2, %r8b
movl %r10d, %r8d
jae 0x7ab4
movb (%r9), %al
movb %al, (%rsi)
movb 0x8(%r9), %al
movb %al, 0x1(%rsi)
movb 0x10(%r9), %al
movb %al, 0x2(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./imgp.h
// Function: imgp_color_quant
void imgp_color_quant(unsigned char *im, int w, int h, int n_colors)
{
	int i;
	unsigned char *pix = im;
	node_heap heap = { 0, 0, 0 };

	oct_node root = node_new(0, 0, 0);
	for (i=0; i < w * h; i++, pix += 3) {
		heap_add(&heap, node_insert(root, pix));
	}

	while (heap.n > n_colors + 1) {
		heap_add(&heap, node_fold(pop_heap(&heap)));
	}

	/*for (i=1; i < heap.n; i++) {
		oct_node got = heap.buf[i];
		double c = got->count;
		got->r = got->r / c + .5;
		got->g = got->g / c + .5;
		got->b = got->b / c + .5;
		printf("%2d | %3lu %3lu %3lu (%d pixels)\n",
		       i, got->r, got->g, got->b, got->count);
	}*/

	for (i=0, pix = im; i < w * h; i++, pix += 3) {
		color_replace(root, pix);
	}

	node_free();
	free(heap.buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r13d
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
xorl %ebx, %ebx
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7940
movq %rax, %r15
imull %r12d, %ebp
testl %ebp, %ebp
jle 0x7b7d
movl %r13d, 0xc(%rsp)
leaq 0x10(%rsp), %r12
movl %ebp, %ebx
movq %r14, %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x79df
movq %r12, %rdi
movq %rax, %rsi
callq 0x7856
addq $0x3, %r13
decl %ebx
jne 0x7b56
movl 0x14(%rsp), %ebx
movl 0xc(%rsp), %r13d
incl %r13d
cmpl %r13d, %ebx
jle 0x7bac
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x78f9
movq %rax, %rdi
callq 0x7a6a
movq %r12, %rdi
movq %rax, %rsi
callq 0x7856
cmpl %r13d, 0x14(%rsp)
jg 0x7b8a
testl %ebp, %ebp
jle 0x7bc3
movq %r15, %rdi
movq %r14, %rsi
callq 0x7aa9
addq $0x3, %r14
decl %ebp
jne 0x7bb0
movq 0x20656(%rip), %rdi     # 0x28220
testq %rdi, %rdi
je 0x7be7
movq 0x60(%rdi), %rbx
callq 0x1030
movq %rbx, 0x20641(%rip)     # 0x28220
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x7bcf
movq 0x18(%rsp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./imgp.h
// Function: rndunit_24to15
uint8_t rndunit_24to15(uint8_t u, int dither)
{
	uint8_t unit = (u & 0b11111000)>>3;
	uint8_t weight = (u & 0b00000111);
	if (dither && (weight - (rand() % 7) >=0) && (unit < 31)) {
		unit++;
	}
	return unit<<3;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
shrb $0x3, %bl
testl %esi, %esi
je 0x7c4b
andb $0x7, %dil
movzbl %dil, %ebp
callq 0x1240
cltq
imulq $-0x6db6db6d, %rax, %rcx # imm = 0x92492493
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x2, %ecx
addl %edx, %ecx
leal (,%rcx,8), %edx
subl %edx, %ecx
addl %eax, %ecx
cmpl %ebp, %ecx
setle %al
cmpb $0x1f, %bl
setne %cl
andb %al, %cl
addb %cl, %bl
shlb $0x3, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./potracelib.h
// Function: path_new
path_t *path_new(void) {
  path_t *p = NULL;
  privpath_t *priv = NULL;
  SAFE_CALLOC(p, 1, path_t);
  memset(p, 0, sizeof(path_t));
  SAFE_CALLOC(priv, 1, privpath_t);
  memset(priv, 0, sizeof(privpath_t));
  p->priv = priv;
  return p;
 calloc_error:
  free(p);
  free(priv);
  return NULL;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x40, %esi
callq 0x1110
movq %rax, %rbx
testq %rax, %rax
je 0x7ccd
movl $0x1, %edi
movl $0xc0, %esi
callq 0x1110
testq %rax, %rax
je 0x7ccd
movq %rax, 0x38(%rbx)
jmp 0x7cd7
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./potracelib.h
// Function: path_free
void path_free(path_t *p) {
  if (p) {
    if (p->priv) {
      free(p->priv->pt);
      free(p->priv->lon);
      free(p->priv->sums);
      free(p->priv->po);
      privcurve_free_members(&p->priv->curve);
      privcurve_free_members(&p->priv->ocurve);
    }
    free(p->priv);
    /* do not free p->fcurve ! */
  }
  free(p);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x7d45
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x7d3e
movq 0x8(%rax), %rdi
callq 0x1030
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq 0x38(%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq 0x38(%rbx), %rax
movq 0x30(%rax), %rdi
callq 0x1030
movq 0x38(%rbx), %rdi
addq $0x38, %rdi
callq 0x7d4e
movq 0x38(%rbx), %rdi
addq $0x78, %rdi
callq 0x7d4e
movq 0x38(%rbx), %rdi
jmp 0x7d40
xorl %edi, %edi
callq 0x1030
movq %rbx, %rdi
popq %rbx
jmp 0x1030