LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/erik[P]gamut/opacity.c
// Function: main
int main(int argc, char** argv)
{
    uint32_t width, height;
    uint16_t opacity;
    pixel_t rgba;

    if (argc != 2) {
        fprintf(stderr, "usage: %s OPACITY_PCT\n", argv[0]);
        return 1;
    }

    long opacity_pct = strtol(argv[1], NULL, 10);

    if (opacity_pct > 100 || opacity_pct < 0) {
        fprintf(stderr, "opacity out of range: %ld%%\n", opacity_pct);
        return 1;
    }

    opacity = (uint16_t)(65535 * (opacity_pct / 100.0));

    read_header(&width, &height);
    write_header(width, height);

    for (uint32_t i = 0; i < height; i++) {
        for (uint32_t j = 0; j < width; j++) {
            read_pixel(&rgba);
            rgba.a = opacity;
            write_pixel(&rgba);
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x1227
movq 0x2df5(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xe04(%rip), %rsi       # 0x2018
movb $0x0, %al
callq 0x1080
movl $0x1, -0x4(%rbp)
jmp 0x130c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1090
movq %rax, -0x30(%rbp)
cmpq $0x64, -0x30(%rbp)
jg 0x124f
cmpq $0x0, -0x30(%rbp)
jge 0x1277
movq 0x2da2(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x30(%rbp), %rdx
leaq 0xdcb(%rip), %rsi       # 0x202f
movb $0x0, %al
callq 0x1080
movl $0x1, -0x4(%rbp)
jmp 0x130c
cvtsi2sdq -0x30(%rbp), %xmm0
movsd 0xd83(%rip), %xmm1      # 0x2008
divsd %xmm1, %xmm0
movsd 0xd7f(%rip), %xmm1      # 0x2010
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movw %ax, -0x1a(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1320
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x13f0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x1305
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x12f8
leaq -0x22(%rbp), %rdi
callq 0x1490
movw -0x1a(%rbp), %ax
movw %ax, -0x1c(%rbp)
leaq -0x22(%rbp), %rdi
callq 0x1500
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x12cb
jmp 0x12fa
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x12bc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x9aa5(%rip), %rax      # 0x109d8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6f96
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x9ac4(%rip), %rax      # 0x10a18
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x9942(%rip), %rdx      # 0x108a8
movq -0x18(%rbp), %rax
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x3670
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6f3a
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x9a2d(%rip), %rax      # 0x109e0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7026
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x7017
leaq 0x9a36(%rip), %rax      # 0x10a18
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x98bc(%rip), %rdx      # 0x108b0
movq -0x18(%rbp), %rax
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x3670
jmp 0x7019
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6fba
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x721d(%rip), %rax      # 0x10a50
cmpl $0x0, (%rax)
je 0x9941
leaq 0x71d5(%rip), %rax      # 0x10a18
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
leaq 0x7215(%rip), %rcx      # 0x10a70
callq 0x3190
movq %rax, -0x10(%rbp)
callq 0x99e0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x71f7(%rip), %eax      # 0x10a70
jge 0x9928
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %ecx
movq 0x71d0(%rip), %rax      # 0x10a68
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movl 0x18(%rax), %ecx
movq 0x71aa(%rip), %rax      # 0x10a68
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movl 0x1c(%rax), %ecx
movq 0x7183(%rip), %rax      # 0x10a68
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %ecx
movq 0x715c(%rip), %rax      # 0x10a68
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9870
cmpl $0x0, 0x7141(%rip)      # 0x10a70
je 0x993f
movq -0x10(%rbp), %rdi
callq 0x3300
jmp 0x99cb
jmp 0x9941
movl $0x1, 0x7125(%rip)      # 0x10a70
callq 0x99e0
movq 0x7111(%rip), %rax      # 0x10a68
movl $0x0, (%rax)
movq 0x7104(%rip), %rax      # 0x10a68
movl $0x0, 0x4(%rax)
leaq 0x70a6(%rip), %rax      # 0x10a18
movq (%rax), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq (%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movl 0x18(%rax), %ecx
movq 0x70d0(%rip), %rax      # 0x10a68
movl %ecx, 0x8(%rax)
leaq 0x7076(%rip), %rax      # 0x10a18
movq (%rax), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq (%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movl 0x1c(%rax), %ecx
movq 0x70a0(%rip), %rax      # 0x10a68
movl %ecx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
cmpl $0x0, 0x7085(%rip)      # 0x10a70
jne 0x99f2
jmp 0x9a93
movl 0x707c(%rip), %eax      # 0x10a74
cmpl 0x7072(%rip), %eax      # 0x10a70
jge 0x9a57
leaq 0x7071(%rip), %rax      # 0x10a78
cmpq %rax, 0x705a(%rip)      # 0x10a68
je 0x9a1c
movq 0x7051(%rip), %rdi      # 0x10a68
callq 0x32d0
movslq 0x704d(%rip), %rdi      # 0x10a70
shlq $0x4, %rdi
callq 0x31e0
movq %rax, 0x7035(%rip)      # 0x10a68
cmpq $0x0, 0x702d(%rip)      # 0x10a68
je 0x9a4b
movl 0x702d(%rip), %eax      # 0x10a70
movl %eax, 0x702b(%rip)      # 0x10a74
jmp 0x9a55
movl $0x0, 0x701f(%rip)      # 0x10a74
jmp 0x9a57
cmpq $0x0, 0x7009(%rip)      # 0x10a68
je 0x9a63
jmp 0x9a93
movq 0x6586(%rip), %rax      # 0xfff0
movq (%rax), %rdi
leaq 0x3d74(%rip), %rsi      # 0xd7e8
movb $0x0, %al
callq 0x3720
movl $0x1, 0x6feb(%rip)      # 0x10a70
leaq 0x6fec(%rip), %rax      # 0x10a78
movq %rax, 0x6fd5(%rip)      # 0x10a68
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9820
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x6fab(%rip), %eax      # 0x10a70
jge 0x9ba9
movq 0x6f96(%rip), %rax      # 0x10a68
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movq 0x6f82(%rip), %rcx      # 0x10a68
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
addl 0x8(%rcx), %eax
movq -0x10(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jl 0x9b81
movq 0x6f60(%rip), %rax      # 0x10a68
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x24(%rcx), %ecx
movq -0x10(%rbp), %rdx
addl 0x2c(%rdx), %ecx
cmpl %ecx, %eax
jge 0x9b81
movq 0x6f3a(%rip), %rax      # 0x10a68
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x28(%rcx), %ecx
movq -0x10(%rbp), %rdx
addl 0x30(%rdx), %ecx
cmpl %ecx, %eax
jge 0x9b81
movq 0x6f13(%rip), %rax      # 0x10a68
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movq 0x6efe(%rip), %rcx      # 0x10a68
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
addl 0x8(%rcx), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x9b83
jmp 0x9b9b
movq 0x6ede(%rip), %rax      # 0x10a68
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x9bb4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9abc
movq 0x6eb8(%rip), %rax      # 0x10a68
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x5471(%rip), %rax      # 0x109d0
movq (%rax), %rdi
leaq 0x547f(%rip), %rax      # 0x109e8
movq (%rax), %rsi
callq 0x7680
movq %rax, -0x8(%rbp)
callq 0xb600
movq %rax, -0x10(%rbp)
leaq 0x5463(%rip), %rax      # 0x109e8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb5ab
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xb660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb5cd
leaq 0x5417(%rip), %rax      # 0x109d0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xb660
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3cc0
cmpq $0x0, -0x18(%rbp)
jne 0xb5df
jmp 0xb5f1
movq -0x18(%rbp), %rdi
callq 0x39f0
movq -0x18(%rbp), %rdi
callq 0x8700
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xb703
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0xb6dd
movq -0x28(%rbp), %rax
cmpl $0x0, 0x7c(%rax)
je 0xb6b5
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x68(%rax)
je 0xb6dd
movq -0x28(%rbp), %rax
cmpl $-0x1, 0x78(%rax)
je 0xb6d3
movq -0x28(%rbp), %rax
movl 0x78(%rax), %eax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x40(%rcx), %eax
jne 0xb6dd
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb70b
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xb6f1
movq $0x0, -0x8(%rbp)
jmp 0xb70b
jmp 0xb6f3
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xb678
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/prospector.c
// Function: execbuf_alloc
static void *
execbuf_alloc(void)
{
    int prot = PROT_READ | PROT_WRITE;
    int flags = MAP_PRIVATE | MAP_ANONYMOUS;
    void *p = mmap(NULL, 4096, prot, flags, -1, 0);
    if (p == MAP_FAILED) {
        fprintf(stderr, "prospector: %s\n", strerror(errno));
        exit(EXIT_FAILURE);
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x3, -0x4(%rbp)
movl $0x22, -0x8(%rbp)
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
xorl %eax, %eax
movl %eax, %r9d
movl $0x1000, %esi           # imm = 0x1000
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x1080
movq %rax, -0x10(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x10(%rbp)
jne 0x1bae
movq 0x447c(%rip), %rax      # 0x5ff8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x11d0
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x28d5(%rip), %rsi      # 0x4472
movb $0x0, %al
callq 0x1110
movl $0x1, %edi
callq 0x11b0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x28ab(%rip), %rsi      # 0x4482
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x28ea(%rip), %rsi      # 0x44d3
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x290f(%rip), %rsi      # 0x450a
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x292a(%rip), %rsi      # 0x4537
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x2949(%rip), %rsi      # 0x4568
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x295d(%rip), %rsi      # 0x458e
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x297a(%rip), %rsi      # 0x45bd
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x2992(%rip), %rsi      # 0x45e7
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x29b6(%rip), %rsi      # 0x461d
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x29d7(%rip), %rsi      # 0x4650
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x29ed(%rip), %rsi      # 0x4678
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x2a08(%rip), %rsi      # 0x46a5
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x2a2f(%rip), %rsi      # 0x46de
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
leaq 0x2a4f(%rip), %rsi      # 0x4710
movb $0x0, %al
callq 0x1110
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/prospector.c
// Function: parse_template
static int
parse_template(struct hf_op *ops, int n, char *template, int flags)
{
    int c = 0;
    int offset = flags & F_U64 ? HF64_XOR : 0;

    for (char *tok = strtok(template, ","); tok; tok = strtok(0, ",")) {
        if (c == n) return 0;
        int found = 0;
        size_t operand = strcspn(tok, ":");
        int sep = tok[operand];
        tok[operand] = 0;
        ops[c].flags = 0;
        for (int i = 0; i < countof(hf_names); i++) {
            if (!strcmp(hf_names[i] + 2, tok)) {
                found = 1;
                ops[c].type = i + offset;
                break;
            }
        }
        if (!found)
            return 0;
        if (sep == ':' && !parse_operand(ops + c, tok + operand + 1))
            return 0;
        c++;
    }
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x24(%rbp), %edx
andl $0x1, %edx
xorl %eax, %eax
movl $0xa, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x2a3a(%rip), %rsi      # 0x4748
callq 0x1160
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x1e45
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x1d36
movl $0x0, -0x4(%rbp)
jmp 0x1e4b
movl $0x0, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x25e0(%rip), %rsi      # 0x4328
callq 0x10d0
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x4c(%rbp)
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x10(%rax)
movl $0x0, -0x50(%rbp)
cmpl $0x14, -0x50(%rbp)
jge 0x1de0
movslq -0x50(%rbp), %rax
leaq 0x24d6(%rip), %rdi      # 0x4270
shlq $0x3, %rax
addq %rax, %rdi
addq $0x2, %rdi
movq -0x38(%rbp), %rsi
callq 0x10f0
cmpl $0x0, %eax
jne 0x1dd3
movl $0x1, -0x3c(%rbp)
movl -0x50(%rbp), %ecx
addl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
jmp 0x1de0
jmp 0x1dd5
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x1d89
cmpl $0x0, -0x3c(%rbp)
jne 0x1def
movl $0x0, -0x4(%rbp)
jmp 0x1e4b
cmpl $0x3a, -0x4c(%rbp)
jne 0x1e23
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq -0x38(%rbp), %rsi
addq -0x48(%rbp), %rsi
addq $0x1, %rsi
callq 0x3a10
cmpl $0x0, %eax
jne 0x1e23
movl $0x0, -0x4(%rbp)
jmp 0x1e4b
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x2911(%rip), %rsi      # 0x4748
callq 0x1160
movq %rax, -0x38(%rbp)
jmp 0x1d17
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl 0x32c6(%rip), %eax      # 0x6108
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x2e66
jmp 0x2e4b
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x2e94
jmp 0x2e55
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x2ee7
jmp 0x2ee9
movq -0x8(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
movl $0x7, %edx
callq 0x1140
cmpl $0x0, %eax
jne 0x2e8a
movl $0x2, 0x3280(%rip)      # 0x6108
jmp 0x2ee9
movl $0x1, 0x3274(%rip)      # 0x6108
movq -0x8(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
movl $0x5, %edx
callq 0x1140
cmpl $0x0, %eax
je 0x2ee5
movq 0x3145(%rip), %rax      # 0x5ff8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x11d0
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x1876(%rip), %rsi      # 0x474a
movb $0x0, %al
callq 0x1110
movl $0x1, %edi
callq 0x11b0
jmp 0x2ee9
jmp 0x2ee9
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x1100
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2f3b
movq 0x30dc(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x184c(%rip), %rsi      # 0x4776
movb $0x0, %al
callq 0x1110
movl $0x1, %edi
callq 0x11b0
movq -0x10(%rbp), %rdi
leaq 0x184f(%rip), %rsi      # 0x4795
callq 0x1180
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2f7c
movq 0x309b(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x182f(%rip), %rsi      # 0x479a
movb $0x0, %al
callq 0x1110
movl $0x1, %edi
callq 0x11b0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/prospector.c
// Function: xoroshiro128plus
static uint64_t
xoroshiro128plus(uint64_t s[2])
{
    uint64_t s0 = s[0];
    uint64_t s1 = s[1];
    uint64_t result = s0 + s1;
    s1 ^= s0;
    s[0] = ((s0 << 24) | (s0 >> 40)) ^ s1 ^ (s1 << 16);
    s[1] = (s1 << 37) | (s1 >> 27);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
xorq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
shlq $0x18, %rcx
movq -0x10(%rbp), %rax
shrq $0x28, %rax
orq %rax, %rcx
xorq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
shlq $0x10, %rax
xorq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
shlq $0x25, %rcx
movq -0x18(%rbp), %rax
shrq $0x1b, %rax
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/prospector.c
// Function: hf_genfunc
static void
hf_genfunc(struct hf_op *ops, int n, int flags, uint64_t s[2])
{
    hf_gen(ops, s, flags);
    for (int i = 1; i < n; i++) {
        do {
            hf_gen(ops + i, s, flags);
        } while (!hf_type_valid(ops[i - 1].type, ops[i].type));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x10(%rbp), %edx
callq 0x3bd0
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x38f7
jmp 0x3897
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl -0x10(%rbp), %edx
callq 0x3bd0
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %esi
callq 0x3c60
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3897
jmp 0x38ec
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x388d
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/prospector.c
// Function: execbuf_unlock
static void
execbuf_unlock(void *buf)
{
    switch (wxr_enabled) {
        case WXR_UNKNOWN:
            abort();
        case WXR_ENABLED:
            mprotect(buf, 4096, PROT_READ | PROT_WRITE);
            break;
        case WXR_DISABLED:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x27f6(%rip), %eax      # 0x6108
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x392f
jmp 0x391b
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x3934
jmp 0x3925
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x3949
jmp 0x394b
callq 0x1030
movq -0x8(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
movl $0x3, %edx
callq 0x1140
jmp 0x394b
jmp 0x394b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/prospector.c
// Function: hf_printfunc
static void
hf_printfunc(const struct hf_op *ops, int n, FILE *f)
{
    if (ops[0].type <= HF32_SUBL)
        fprintf(f, "uint32_t\nhash(uint32_t x)\n{\n");
    else
        fprintf(f, "uint64_t\nhash(uint64_t x)\n{\n");
    for (int i = 0; i < n; i++) {
        char buf[64];
        hf_print(ops + i, buf);
        fprintf(f, "    %s\n", buf);
    }
    fprintf(f, "    return x;\n}\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x9, (%rax)
ja 0x3990
movq -0x18(%rbp), %rdi
leaq 0xe3c(%rip), %rsi       # 0x47c3
movb $0x0, %al
callq 0x1110
jmp 0x39a2
movq -0x18(%rbp), %rdi
leaq 0xe45(%rip), %rsi       # 0x47e0
movb $0x0, %al
callq 0x1110
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x39ea
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq -0x60(%rbp), %rsi
callq 0x3cd0
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rdx
leaq 0xe25(%rip), %rsi       # 0x47fd
movb $0x0, %al
callq 0x1110
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39a9
movq -0x18(%rbp), %rdi
leaq 0xe10(%rip), %rsi       # 0x4805
movb $0x0, %al
callq 0x1110
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/prospector.c
// Function: parse_operand
static int
parse_operand(struct hf_op *op, char *buf)
{
    op->flags |= FOP_LOCKED;
    switch (op->type) {
        case HF32_NOT:
        case HF64_NOT:
        case HF32_BSWAP:
        case HF64_BSWAP:
            return 0;
        case HF32_XOR:
        case HF32_MUL:
        case HF32_ADD:
        case HF64_XOR:
        case HF64_MUL:
        case HF64_ADD:
            op->constant = strtoull(buf, 0, 16);
            return 1;
        case HF32_ROT:
        case HF32_XORL:
        case HF32_XORR:
        case HF32_ADDL:
        case HF32_SUBL:
        case HF64_ROT:
        case HF64_XORL:
        case HF64_XORR:
        case HF64_ADDL:
        case HF64_SUBL:
            op->constant = atoi(buf);
            return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x3, %eax
jb 0x3a9b
jmp 0x3a3d
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0x3ac1
jmp 0x3a47
movl -0x1c(%rbp), %eax
addl $-0x4, %eax
subl $0x2, %eax
jb 0x3a92
jmp 0x3a54
movl -0x1c(%rbp), %eax
addl $-0x6, %eax
subl $0x4, %eax
jb 0x3ac1
jmp 0x3a61
movl -0x1c(%rbp), %eax
addl $-0xa, %eax
subl $0x3, %eax
jb 0x3a9b
jmp 0x3a6e
movl -0x1c(%rbp), %eax
subl $0xd, %eax
je 0x3ac1
jmp 0x3a78
movl -0x1c(%rbp), %eax
addl $-0xe, %eax
subl $0x2, %eax
jb 0x3a92
jmp 0x3a85
movl -0x1c(%rbp), %eax
addl $-0x10, %eax
subl $0x4, %eax
jb 0x3ac1
jmp 0x3ade
movl $0x0, -0x4(%rbp)
jmp 0x3ae5
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x10e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3ae5
movq -0x18(%rbp), %rdi
callq 0x1190
movslq %eax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3ae5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x37d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x13, %rax
ja 0x3bc0
movq -0x20(%rbp), %rax
leaq 0x698(%rip), %rcx       # 0x41c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x3bc0
movq -0x18(%rbp), %rax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3bc0
movq -0x18(%rbp), %rax
orl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3bc0
movq -0x18(%rbp), %rax
movl $0x1f, %ecx
xorl %edx, %edx
divq %rcx
addq $0x1, %rdx
movq -0x8(%rbp), %rax
movq %rdx, 0x8(%rax)
jmp 0x3bc0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3bc0
movq -0x18(%rbp), %rcx
orq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3bc0
movq -0x18(%rbp), %rax
movl $0x3f, %ecx
xorl %edx, %edx
divq %rcx
addq $0x1, %rdx
movq -0x8(%rbp), %rax
movq %rdx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/prospector.c
// Function: hf_gen
static void
hf_gen(struct hf_op *op, uint64_t s[2], int flags)
{
    uint64_t r = xoroshiro128plus(s);
    int min = flags & F_TINY ? 3 : 0;
    op->type = (r % (9 - min)) + min + (flags & F_U64 ? 9 : 0);
    hf_randomize(op, s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x37d0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edx
andl $0x2, %edx
xorl %eax, %eax
movl $0x3, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl $0x9, %ecx
subl -0x24(%rbp), %ecx
movslq %ecx, %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movl -0x14(%rbp), %esi
andl $0x1, %esi
xorl %ecx, %ecx
movl $0x9, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3af0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/prospector.c
// Function: hf_type_valid
static int
hf_type_valid(enum hf_type a, enum hf_type b)
{
    switch (a) {
        case HF32_NOT:
        case HF32_BSWAP:
        case HF32_XOR:
        case HF32_MUL:
        case HF32_ADD:
        case HF32_ROT:
        case HF64_NOT:
        case HF64_BSWAP:
        case HF64_XOR:
        case HF64_MUL:
        case HF64_ADD:
        case HF64_ROT:
            return a != b;
        case HF32_XORL:
        case HF32_XORR:
        case HF32_ADDL:
        case HF32_SUBL:
        case HF64_XORL:
        case HF64_XORR:
        case HF64_ADDL:
        case HF64_SUBL:
            return 1;
    }
    abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x6, %eax
jb 0x3ca2
jmp 0x3c7b
movl -0x10(%rbp), %eax
addl $-0x6, %eax
subl $0x4, %eax
jb 0x3cb5
jmp 0x3c88
movl -0x10(%rbp), %eax
addl $-0xa, %eax
subl $0x6, %eax
jb 0x3ca2
jmp 0x3c95
movl -0x10(%rbp), %eax
addl $-0x10, %eax
subl $0x4, %eax
jb 0x3cb5
jmp 0x3cbe
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x3cc3
movl $0x1, -0x4(%rbp)
jmp 0x3cc3
callq 0x1030
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x735d
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x732c
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %edx
movl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
cvtsi2sd %edx, %xmm1
movzbl 0x1(%rax,%rcx), %edx
cvtsi2sd %edx, %xmm0
movsd 0x2ad0d(%rip), %xmm2    # 0x31ff0
mulsd %xmm2, %xmm0
movsd 0x2ad09(%rip), %xmm2    # 0x31ff8
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movzbl 0x2(%rax,%rcx), %eax
cvtsi2sd %eax, %xmm0
movsd 0x2acf8(%rip), %xmm2    # 0x32000
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x72b3
imull $0x3, -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x72a0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x120(%rbp), %r8
xorl %ecx, %ecx
movl $0x10, %r9d
movl $0x10, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
callq 0x6690
xorps %xmm0, %xmm0
movsd %xmm0, -0x128(%rbp)
movl $0x0, -0x12c(%rbp)
cmpl $0x100, -0x12c(%rbp)    # imm = 0x100
jge 0x76b3
movslq -0x12c(%rbp), %rax
movzbl -0x120(%rbp,%rax), %eax
cvtsi2sd %eax, %xmm0
addsd -0x128(%rbp), %xmm0
movsd %xmm0, -0x128(%rbp)
movl -0x12c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x12c(%rbp)
jmp 0x7673
movsd -0x128(%rbp), %xmm0
movsd 0x2a945(%rip), %xmm1    # 0x32008
divsd %xmm1, %xmm0
movsd %xmm0, -0x128(%rbp)
movl $0x0, -0x130(%rbp)
cmpl $0x100, -0x130(%rbp)    # imm = 0x100
jge 0x77a2
movq -0x18(%rbp), %rax
movl -0x130(%rbp), %ecx
movl %ecx, %edx
addl $0x7, %edx
testl %ecx, %ecx
cmovsl %edx, %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
addb %dl, %dl
movb %dl, (%rax,%rcx)
movsd -0x128(%rbp), %xmm1
movslq -0x130(%rbp), %rax
movzbl -0x120(%rbp,%rax), %eax
cvtsi2sd %eax, %xmm0
ucomisd %xmm1, %xmm0
jb 0x775d
movq -0x18(%rbp), %rax
movq %rax, -0x138(%rbp)
movl -0x130(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x138(%rbp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
orl $0x1, %edx
movb %dl, (%rax,%rcx)
jmp 0x778c
movq -0x18(%rbp), %rax
movq %rax, -0x140(%rbp)
movl -0x130(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x140(%rbp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
andl $-0x2, %edx
movb %dl, (%rax,%rcx)
jmp 0x778e
movl -0x130(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x130(%rbp)
jmp 0x76d9
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x68(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x68(%rcx), %ecx
cmpl %ecx, %eax
jge 0x7c2c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7cb6
movq -0x10(%rbp), %rax
movzbl 0x68(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x68(%rcx), %ecx
cmpl %ecx, %eax
jle 0x7c49
movl $0x1, -0x4(%rbp)
jmp 0x7cb6
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x69(%rcx), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x6b(%rcx), %ecx
sarl %cl, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x69(%rcx), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x6b(%rcx), %ecx
sarl %cl, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x7c9f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x24(%rbp)
jmp 0x7cb0
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x7cf3
jmp 0x7d9b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x7d3a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x7c00
cmpl $0x0, %eax
jle 0x7d3a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x7c00
cmpl $0x0, %eax
jg 0x7d5a
jmp 0x7d9b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x1c(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x7cda
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jle 0x7e4a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7c00
cmpl $0x0, %eax
jl 0x7e1c
jmp 0x7e4a
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
jmp 0x7dda
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x6a(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7eaf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7cc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7dc0
jmp 0x7f62
movq -0x10(%rbp), %rax
movzbl 0x6a(%rax), %ecx
orl $0x1, %ecx
movb %cl, 0x6a(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x7ed2
movq -0x8(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x7f25
jmp 0x7ee3
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x7f02
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x400, %ecx            # imm = 0x400
movl %ecx, (%rax)
jmp 0x7ee3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq (%rax), %rsi
shlq $0x3, %rsi
callq 0x11b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x4(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x4(%rsi)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7dc0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jg 0x7f93
movq $0x0, -0x8(%rbp)
jmp 0x8013
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rdx)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x1c(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x7cc0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movq %rdx, -0x10(%rbp)
cmpl $0x1, 0x32bc9(%rip)     # 0x3ac08
jg 0x8078
movl $0x70, %edi
movl $0x800, %esi            # imm = 0x800
callq 0x1120
movq %rax, -0x18(%rbp)
movq 0x32bb5(%rip), %rcx     # 0x3ac10
movq -0x18(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x32ba2(%rip)     # 0x3ac10
movl $0x7ff, 0x32b90(%rip)   # imm = 0x7FF
movq 0x32b91(%rip), %rax     # 0x3ac10
movl 0x32b83(%rip), %ecx     # 0x3ac08
movl %ecx, %edx
addl $-0x1, %edx
movl %edx, 0x32b78(%rip)     # 0x3ac08
movslq %ecx, %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movb -0x1(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x69(%rax)
movb -0x2(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x6b(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x60(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x80d2
movq -0x10(%rbp), %rax
movb 0x68(%rax), %cl
addb $0x1, %cl
movb %cl, 0x68(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)