LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_clear_form_values
static int eweb_clear_form_values(eweb_os_t *w, eweb_os_hit_args_t *args) {
	assert(args);
	if (!args->form_values)
		return EWEB_OK;
	for (args->form_value_counter--; args->form_value_counter >= 0; args->form_value_counter--)
		eweb_free(w, args->form_values[args->form_value_counter].data);
	eweb_free(w, args->form_values);
	args->form_values = NULL;
	return EWEB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5659
jmp 0x5678
leaq 0x2399(%rip), %rdi      # 0x79f9
leaq 0x22e1(%rip), %rsi      # 0x7948
movl $0x27, %edx
leaq 0x2bd3(%rip), %rcx      # 0x8246
callq 0x2100
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x568c
movl $0x0, -0x4(%rbp)
jmp 0x56fe
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jl 0x56da
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
imulq $0x18, 0x30(%rcx), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
callq 0x5130
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0x569c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x5130
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/eweb.c
// Function: eweb_strtok
static char *eweb_strtok(char *restrict s, const char *restrict sep, char **restrict p) {
	if (!s && !(s = *p))
		return NULL;
	s += strspn(s, sep);
	if (!*s)
		return *p = 0;
	*p = s + strcspn(s, sep);
	if (**p)
		*(*p)++ = 0;
	else
		*p = 0;
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5749
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x5749
movq $0x0, -0x8(%rbp)
jmp 0x57d4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2150
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x577c
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x57d4
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2170
movq -0x28(%rbp), %rcx
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x57c1
movq -0x20(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb $0x0, (%rax)
jmp 0x57cc
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/unix.c
// Function: eweb_accept
static long eweb_accept(eweb_os_t *w, int listenfd) {
	assert(w);
	struct sockaddr_in cli_addr = { 0 };
	if (doing_shutdown)
		return -1;
	socklen_t length = sizeof(cli_addr);
	errno = 0;
	const int socketfd = accept(listenfd, (struct sockaddr *)&cli_addr, &length);
	if (socketfd < 0) {
		w->log(w, EWEB_ERROR, "accept failed: %s", strerror(errno));
		return socketfd;
	}

	struct timeval timeout = { .tv_sec = 60, .tv_usec = 0 };
	errno = 0;
	if (setsockopt(socketfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(struct timeval)) < 0) {
		w->log(w, EWEB_ERROR, "setsocketopt(SO_RCVTIMEO) failed: %s", strerror(errno));
		w->close(w, socketfd);
		return -1;
	}
	return socketfd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5af8
jmp 0x5b17
leaq 0x1a36(%rip), %rdi      # 0x7535
leaq 0x28bc(%rip), %rsi      # 0x83c2
movl $0x7b, %edx
leaq 0x295c(%rip), %rcx      # 0x846e
callq 0x2100
leaq -0x24(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2130
movl 0x569f(%rip), %eax      # 0xb1cc
cmpl $0x0, %eax
je 0x5b3f
movq $-0x1, -0x8(%rbp)
jmp 0x5c54
movl $0x10, -0x28(%rbp)
callq 0x2050
movl $0x0, (%rax)
movl -0x14(%rbp), %edi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x22c0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x5bb3
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x22f0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %r8
movq %rax, %rcx
movl $0x1, %esi
leaq 0x28f0(%rip), %rdx      # 0x8491
movb $0x0, %al
callq *%r8
movslq -0x2c(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5c54
movq 0x2ae6(%rip), %rax      # 0x86a0
movq %rax, -0x40(%rbp)
movq 0x2ae3(%rip), %rax      # 0x86a8
movq %rax, -0x38(%rbp)
callq 0x2050
movl $0x0, (%rax)
movl -0x2c(%rbp), %edi
movl $0x1, %esi
movl $0x14, %edx
leaq -0x40(%rbp), %rcx
movl $0x10, %r8d
callq 0x2090
cmpl $0x0, %eax
jge 0x5c4c
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x22f0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %r8
movq %rax, %rcx
movl $0x1, %esi
leaq 0x2877(%rip), %rdx      # 0x84a3
movb $0x0, %al
callq *%r8
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq *%rax
movq $-0x1, -0x8(%rbp)
jmp 0x5c54
movslq -0x2c(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/unix.c
// Function: eweb_sleep
static long eweb_sleep(eweb_os_t *w, unsigned seconds) {
	assert(w);
	UNUSED(w);
	long i = seconds;
	while((i = sleep(i)));
	return EWEB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5d88
jmp 0x5da7
leaq 0x17a6(%rip), %rdi      # 0x7535
leaq 0x262c(%rip), %rsi      # 0x83c2
movl $0xb5, %edx
leaq 0x27b1(%rip), %rcx      # 0x8553
callq 0x2100
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0x2300
movl %eax, %eax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x5dc7
jmp 0x5dae
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/unix.c
// Function: eweb_log
static long eweb_log(eweb_os_t *w, int error, const char *fmt, ...) {
	assert(w);
	FILE *output = w->file ? w->file : stderr;
	va_list ap;
	va_start(ap, fmt);
	fprintf(output, "%d: ", error);
	vfprintf(output, fmt, ap);
	fputc('\n', output);
	va_end(ap);
	fflush(output);
	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x5e0b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5e34
jmp 0x5e53
leaq 0x16fa(%rip), %rdi      # 0x7535
leaq 0x2580(%rip), %rsi      # 0x83c2
movl $0x2a, %edx
leaq 0x2730(%rip), %rcx      # 0x857e
callq 0x2100
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x5e75
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0xf8(%rbp)
jmp 0x5e86
movq 0x5174(%rip), %rax      # 0xaff0
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x30, -0x3c(%rbp)
movl $0x18, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x26f1(%rip), %rsi      # 0x85b1
xorl %eax, %eax
callq 0x21b0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x22b0
movq -0x20(%rbp), %rsi
movl $0xa, %edi
callq 0x2160
movq -0x20(%rbp), %rdi
callq 0x2210
movslq -0xc(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/unix.c
// Function: eweb_init
static long eweb_init(eweb_os_t *w) {
	UNUSED(w);
#ifndef SIGCLD
	signal(SIGCHLD, SIG_IGN);
#else
	signal(SIGCLD, SIG_IGN);
#endif
	signal(SIGHUP,  SIG_IGN); /* ignore terminal hangups */
	signal(SIGPIPE, SIG_IGN); /* ignore broken pipes */
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x11, %edi
movl $0x1, %esi
callq 0x21a0
movl $0x1, %edi
movl $0x1, %esi
callq 0x21a0
movl $0xd, %edi
movl $0x1, %esi
callq 0x21a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/unix.c
// Function: eweb_thread_exit
static long eweb_thread_exit(eweb_os_t *w, int exit_code) {
	assert(w);
	UNUSED(w);
	if (w->threading_mode == EWEB_TM_MULTI_PROCESS_E) {
		w->exit(w, exit_code);
	} else if (w->threading_mode == EWEB_TM_MULTI_THREADS_E) {
		UNUSED(exit_code);
		pthread_exit(NULL);
	} else {
		UNUSED(exit_code);
	}
	return EWEB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x61d8
jmp 0x61f7
leaq 0x1356(%rip), %rdi      # 0x7535
leaq 0x21dc(%rip), %rsi      # 0x83c2
movl $0xbd, %edx
leaq 0x2482(%rip), %rcx      # 0x8674
callq 0x2100
movq -0x8(%rbp), %rax
movb 0x98(%rax), %al
shrb %al
andb $0x3, %al
movzbl %al, %eax
cmpl $0x2, %eax
jne 0x6220
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq *%rax
jmp 0x6241
movq -0x8(%rbp), %rax
movb 0x98(%rax), %al
shrb %al
andb $0x3, %al
movzbl %al, %eax
cmpl $0x3, %eax
jne 0x623f
xorl %eax, %eax
movl %eax, %edi
callq 0x21f0
jmp 0x6241
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/unix.c
// Function: eweb_os_new
eweb_os_t *eweb_os_new(eweb_allocator_t *allocator, eweb_threading_mode_e mode) {
	eweb_os_t *w = NULL;
	const eweb_allocator_t *a = allocator ? allocator : &eweb_os_default_allocator;
	w = a->malloc(a->arena, sizeof(*w));
	if (!w)
		return w;
	memset(w, 0, sizeof(*w));
	*w = eweb_os;
	w->file = stderr;
	w->allocator = *a;
	switch (mode) {
	case EWEB_TM_SINGLE_THREAD_E: break;
	case EWEB_TM_MULTI_PROCESS_E: break;
	default: /* fall through */
	case EWEB_TM_MULTI_THREADS_E:
		mode = EWEB_TM_MULTI_THREADS_E;
		break;
	}
	w->threading_mode = mode;
	return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6298
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x62a5
leaq 0x4b21(%rip), %rax      # 0xadc0
movq %rax, -0x30(%rbp)
jmp 0x62a5
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x18(%rcx), %rdi
movl $0xa0, %esi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x62db
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x63ac
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movups %xmm0, 0x90(%rax)
movups %xmm0, 0x80(%rax)
movups %xmm0, 0x70(%rax)
movups %xmm0, 0x60(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq -0x20(%rbp), %rdi
leaq 0x49fe(%rip), %rsi      # 0xad20
movl $0xa0, %edx
callq 0x21d0
movq 0x4cbd(%rip), %rax      # 0xaff0
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0x6378
jmp 0x6364
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x637a
jmp 0x636e
movl -0x34(%rbp), %eax
subl $0x3, %eax
je 0x637e
jmp 0x637c
jmp 0x6385
jmp 0x6385
jmp 0x637e
movl $0x3, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movb %cl, %dl
movb 0x98(%rax), %cl
andb $0x3, %dl
shlb %dl
andb $-0x7, %cl
orb %dl, %cl
movb %cl, 0x98(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/unix.c
// Function: eweb_os_delete
void eweb_os_delete(eweb_os_t *w) {
	if (!w)
		return;
	eweb_allocator_t allocator = w->allocator;
	allocator.free(allocator.arena, w);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x63d5
jmp 0x6406
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/unix.c
// Function: inthandler
static void inthandler(int sig) {
	if (doing_shutdown == 1)
		return;
	doing_shutdown = 1;
	fputs("web-server shutting down\n", stderr); // !!
	close(listenfd);
	if (sig != SIGUSR1)
		exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x4dab(%rip), %eax      # 0xb1cc
cmpl $0x1, %eax
jne 0x6428
jmp 0x6460
movl $0x1, 0x4d9a(%rip)      # 0xb1cc
movq 0x4bb7(%rip), %rax      # 0xaff0
movq (%rax), %rsi
leaq 0x2011(%rip), %rdi      # 0x8454
callq 0x2110
movl 0x4d82(%rip), %edi      # 0xb1d0
callq 0x2140
cmpl $0xa, -0x4(%rbp)
je 0x6460
xorl %edi, %edi
callq 0x22e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/howerj[P]eweb/unix.c
// Function: eweb_thread_main
static void *eweb_thread_main(void *targs) {
	eweb_os_hit_args_t *args = (struct eweb_os_hit_args *)targs;
	pthread_detach(pthread_self());
	eweb_hit(args->w, args);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x2280
movq %rax, %rdi
callq 0x2220
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c90
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: init_dir_rules
static void init_dir_rules(void)
{
  set_dir_action("box=./box:rw");
  set_dir_action("bin");
  set_dir_action("dev:dev");
  set_dir_action("lib");
  set_dir_action("lib64:maybe");
  set_dir_action("proc=proc:fs");
  set_dir_action("usr");
}

// Assembly:
pushq %rax
leaq 0x3a47(%rip), %rdi      # 0x649f
callq 0x2ab0
leaq 0x3a48(%rip), %rdi      # 0x64ac
callq 0x2ab0
leaq 0x3a40(%rip), %rdi      # 0x64b0
callq 0x2ab0
leaq 0x3a3c(%rip), %rdi      # 0x64b8
callq 0x2ab0
leaq 0x3a34(%rip), %rdi      # 0x64bc
callq 0x2ab0
leaq 0x3a34(%rip), %rdi      # 0x64c8
callq 0x2ab0
leaq 0x3a35(%rip), %rdi      # 0x64d5
callq 0x2ab0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: set_dir_action
static int set_dir_action(char *arg)
{
  arg = xstrdup(arg);

  char *colon = strchr(arg, ':');
  unsigned int flags = 0;
  while (colon)
    {
      *colon++ = 0;
      char *next = strchr(colon, ':');
      if (next)
	*next = 0;
      flags |= parse_dir_option(colon);
      colon = next;
    }

  char *eq = strchr(arg, '=');
  if (eq)
    {
      *eq++ = 0;
      return add_dir_rule(arg, (*eq ? eq : NULL), flags);
    }
  else
    {
      char *out = xmalloc(1 + strlen(arg) + 1);
      sprintf(out, "/%s", arg);
      return add_dir_rule(arg, out, flags);
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3390
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3a, %esi
callq 0x21f0
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x2b42
movq 0x30(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rsp)
movb $0x0, (%rax)
movq 0x30(%rsp), %rdi
movl $0x3a, %esi
callq 0x21f0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2b24
movq 0x20(%rsp), %rax
movb $0x0, (%rax)
movq 0x30(%rsp), %rdi
callq 0x33d0
orl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2ae4
movq 0x38(%rsp), %rdi
movl $0x3d, %esi
callq 0x21f0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2bb4
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rsp)
movb $0x0, (%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2b94
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
jmp 0x2b9c
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x2b9c
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movl 0x2c(%rsp), %edx
callq 0x3440
movl %eax, 0x44(%rsp)
jmp 0x2c02
movq 0x38(%rsp), %rdi
callq 0x2180
movq %rax, %rdi
addq $0x1, %rdi
addq $0x1, %rdi
callq 0x35b0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rdx
leaq 0x452d(%rip), %rsi      # 0x7111
movb $0x0, %al
callq 0x2460
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x2c(%rsp), %edx
callq 0x3440
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: set_env_action
static int
set_env_action(char *a0)
{
  struct env_rule *r = xmalloc(sizeof(*r) + strlen(a0) + 1);
  char *a = (char *)(r+1);
  strcpy(a, a0);

  char *sep = strchr(a, '=');
  if (sep == a)
    return 0;
  r->var = a;
  if (sep)
    {
      *sep++ = 0;
      r->val = sep;
    }
  else
    r->val = NULL;
  *last_env_rule = r;
  last_env_rule = &r->next;
  r->next = NULL;
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2180
movq %rax, %rdi
addq $0x20, %rdi
addq $0x1, %rdi
callq 0x35b0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2090
movq 0x8(%rsp), %rdi
movl $0x3d, %esi
callq 0x21f0
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x2d4d
movl $0x0, 0x24(%rsp)
jmp 0x2dc3
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rsp)
je 0x2d82
movq (%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, (%rsp)
movb $0x0, (%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2d8f
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x74d5(%rip), %rax      # 0xa270
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x74c2(%rip)      # 0xa270
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: meta_open
static void
meta_open(const char *name)
{
  if (!strcmp(name, "-"))
    {
      metafile = stdout;
      return;
    }
  setreuid(geteuid(), getuid());
  metafile = fopen(name, "w");
  setreuid(geteuid(), getuid());
  if (!metafile)
    die("Failed to open metafile '%s'",name);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x40e9(%rip), %rsi      # 0x6ece
callq 0x22f0
cmpl $0x0, %eax
jne 0x2e02
movq 0x71ca(%rip), %rax      # 0x9fc0
movq (%rax), %rax
movq %rax, 0x7530(%rip)      # 0xa330
jmp 0x2e69
callq 0x2250
movl %eax, 0x8(%rsp)
callq 0x21b0
movl 0x8(%rsp), %edi
movl %eax, %esi
callq 0x23d0
movq 0x10(%rsp), %rdi
leaq 0x3683(%rip), %rsi      # 0x64aa
callq 0x2410
movq %rax, 0x74fd(%rip)      # 0xa330
callq 0x2250
movl %eax, 0xc(%rsp)
callq 0x21b0
movl 0xc(%rsp), %edi
movl %eax, %esi
callq 0x23d0
cmpq $0x0, 0x74dc(%rip)      # 0xa330
jne 0x2e69
movq 0x10(%rsp), %rsi
leaq 0x406e(%rip), %rdi      # 0x6ed0
movb $0x0, %al
callq 0x2ed0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: show_version
static void
show_version(void)
{
  printf("Process isolator 1.0\n");
  printf("(c) 2012 Martin Mares and Bernard Blackham\n");
  printf("\nCompile-time configuration:\n");
  printf("Sandbox directory: %s\n", CONFIG_ISOLATE_BOX_DIR);
  printf("Sandbox credentials: uid=%u-%u gid=%u-%u\n",
    CONFIG_ISOLATE_FIRST_UID,
    CONFIG_ISOLATE_FIRST_UID + CONFIG_ISOLATE_NUM_BOXES - 1,
    CONFIG_ISOLATE_FIRST_GID,
    CONFIG_ISOLATE_FIRST_GID + CONFIG_ISOLATE_NUM_BOXES - 1);
}

// Assembly:
pushq %rax
leaq 0x4075(%rip), %rdi      # 0x6eed
movb $0x0, %al
callq 0x2200
leaq 0x407d(%rip), %rdi      # 0x6f03
movb $0x0, %al
callq 0x2200
leaq 0x409b(%rip), %rdi      # 0x6f2f
movb $0x0, %al
callq 0x2200
leaq 0x40ab(%rip), %rdi      # 0x6f4d
leaq 0x40bb(%rip), %rsi      # 0x6f64
movb $0x0, %al
callq 0x2200
leaq 0x40b6(%rip), %rdi      # 0x6f6d
movl $0xea60, %ecx           # imm = 0xEA60
movl $0x15f8f, %r8d          # imm = 0x15F8F
movl %ecx, %esi
movl %r8d, %edx
movb $0x0, %al
callq 0x2200
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: box_init
static void
box_init(void)
{
  if (box_id < 0 || box_id >= CONFIG_ISOLATE_NUM_BOXES)
    die("Sandbox ID out of range (allowed: 0-%d)", CONFIG_ISOLATE_NUM_BOXES-1);
  box_uid = CONFIG_ISOLATE_FIRST_UID + box_id;
  box_gid = CONFIG_ISOLATE_FIRST_GID + box_id;

  snprintf(box_dir, sizeof(box_dir), "%s/%d", CONFIG_ISOLATE_BOX_DIR, box_id);
  make_dir(box_dir);
  if (chdir(box_dir) < 0)
    die("chdir(%s): %m", box_dir);
}

// Assembly:
pushq %rax
cmpl $0x0, 0x72a8(%rip)      # 0xa2b0
jl 0x3016
cmpl $0x7530, 0x729c(%rip)   # imm = 0x7530
jl 0x3029
leaq 0x4193(%rip), %rdi      # 0x71b0
movl $0x752f, %esi           # imm = 0x752F
movb $0x0, %al
callq 0x2ed0
movl 0x7281(%rip), %eax      # 0xa2b0
addl $0xea60, %eax           # imm = 0xEA60
movl %eax, 0x743e(%rip)      # 0xa478
movl 0x7270(%rip), %eax      # 0xa2b0
addl $0xea60, %eax           # imm = 0xEA60
movl %eax, 0x7431(%rip)      # 0xa47c
movl 0x725e(%rip), %r8d      # 0xa2b0
leaq 0x7427(%rip), %rdi      # 0xa480
movl $0x400, %esi            # imm = 0x400
leaq 0x4173(%rip), %rdx      # 0x71d8
leaq 0x3ef8(%rip), %rcx      # 0x6f64
movb $0x0, %al
callq 0x2210
leaq 0x7406(%rip), %rdi      # 0xa480
callq 0x4210
leaq 0x73fa(%rip), %rdi      # 0xa480
callq 0x21a0
cmpl $0x0, %eax
jge 0x30a5
leaq 0x4147(%rip), %rdi      # 0x71de
leaq 0x73e2(%rip), %rsi      # 0xa480
movb $0x0, %al
callq 0x2ed0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: cg_init
static void
cg_init(void)
{
  if (!cg_enable)
    return;

  char *cg_root = CONFIG_ISOLATE_CGROUP_ROOT;
  if (!dir_exists(cg_root))
    die("Control group filesystem at %s not mounted", cg_root);

  snprintf(cg_name, sizeof(cg_name), "box-%d", box_id);
  msg("Using control group %s\n", cg_name);
}

// Assembly:
pushq %rax
cmpl $0x0, 0x7208(%rip)      # 0xa2c0
jne 0x30bc
jmp 0x311c
leaq 0x401c(%rip), %rax      # 0x70df
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x42d0
cmpl $0x0, %eax
jne 0x30e7
movq (%rsp), %rsi
leaq 0x412c(%rip), %rdi      # 0x720c
movb $0x0, %al
callq 0x2ed0
movl 0x71c3(%rip), %ecx      # 0xa2b0
leaq 0x726c(%rip), %rdi      # 0xa360
movl $0x100, %esi            # imm = 0x100
leaq 0x4137(%rip), %rdx      # 0x7237
movb $0x0, %al
callq 0x2210
leaq 0x4130(%rip), %rdi      # 0x723e
leaq 0x724b(%rip), %rsi      # 0xa360
movb $0x0, %al
callq 0x4090
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: init
static void
init(void)
{
  msg("Preparing sandbox directory\n");
  rmtree("box");
  if (mkdir("box", 0700) < 0)
    die("Cannot create box: %m");
  if (chown("box", orig_uid, orig_gid) < 0)
    die("Cannot chown box: %m");

  cg_prepare();
  set_quota();

  puts(box_dir);
}

// Assembly:
pushq %rax
leaq 0x412e(%rip), %rdi      # 0x7256
movb $0x0, %al
callq 0x4090
leaq 0x3e33(%rip), %rdi      # 0x6f69
callq 0x4330
leaq 0x3e27(%rip), %rdi      # 0x6f69
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x20b0
cmpl $0x0, %eax
jge 0x315f
leaq 0x411b(%rip), %rdi      # 0x7273
movb $0x0, %al
callq 0x2ed0
movl 0x71b3(%rip), %esi      # 0xa318
movl 0x71b1(%rip), %edx      # 0xa31c
leaq 0x3df7(%rip), %rdi      # 0x6f69
callq 0x23e0
cmpl $0x0, %eax
jge 0x318a
leaq 0x4106(%rip), %rdi      # 0x7289
movb $0x0, %al
callq 0x2ed0
callq 0x4360
callq 0x44d0
leaq 0x72e5(%rip), %rdi      # 0xa480
callq 0x20c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: run
static void
run(char **argv)
{
  if (!dir_exists("box"))
    die("Box directory not found, did you run `isolate --init'?");

  chowntree("box", box_uid, box_gid);
  cleanup_ownership = 1;

  if (pipe(error_pipes) < 0)
    die("pipe: %m");
  for (int i=0; i<2; i++)
    if (fcntl(error_pipes[i], F_SETFD, fcntl(error_pipes[i], F_GETFD) | FD_CLOEXEC) < 0 ||
        fcntl(error_pipes[i], F_SETFL, fcntl(error_pipes[i], F_GETFL) | O_NONBLOCK) < 0)
      die("fcntl on pipe: %m");

  box_pid = clone(
    box_inside,			// Function to execute as the body of the new process
    argv,			// Pass our stack
    SIGCHLD | CLONE_NEWIPC | CLONE_NEWNET | CLONE_NEWNS | CLONE_NEWPID,
    argv);			// Pass the arguments
  if (box_pid < 0)
    die("clone: %m");
  if (!box_pid)
    die("clone returned 0");
  box_keeper();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x3da9(%rip), %rdi      # 0x6f69
callq 0x42d0
cmpl $0x0, %eax
jne 0x31d8
leaq 0x439b(%rip), %rdi      # 0x756c
movb $0x0, %al
callq 0x2ed0
movl 0x729a(%rip), %esi      # 0xa478
movl 0x7298(%rip), %edx      # 0xa47c
leaq 0x3d7e(%rip), %rdi      # 0x6f69
callq 0x38b0
movl $0x1, 0x714a(%rip)      # 0xa344
leaq 0x767f(%rip), %rdi      # 0xa880
callq 0x22a0
cmpl $0x0, %eax
jge 0x3219
leaq 0x439a(%rip), %rdi      # 0x75ac
movb $0x0, %al
callq 0x2ed0
movl $0x0, 0xc(%rsp)
cmpl $0x2, 0xc(%rsp)
jge 0x32df
movslq 0xc(%rsp), %rcx
leaq 0x7648(%rip), %rax      # 0xa880
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movslq 0xc(%rsp), %rcx
leaq 0x7635(%rip), %rax      # 0xa880
movl (%rax,%rcx,4), %edi
movl $0x1, %esi
movb $0x0, %al
callq 0x2110
movl 0x8(%rsp), %edi
movl %eax, %edx
orl $0x1, %edx
movl $0x2, %esi
movb $0x0, %al
callq 0x2110
cmpl $0x0, %eax
jl 0x32bf
movslq 0xc(%rsp), %rcx
leaq 0x7600(%rip), %rax      # 0xa880
movl (%rax,%rcx,4), %eax
movl %eax, 0x4(%rsp)
movslq 0xc(%rsp), %rcx
leaq 0x75ed(%rip), %rax      # 0xa880
movl (%rax,%rcx,4), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x2110
movl 0x4(%rsp), %edi
movl %eax, %edx
orl $0x800, %edx            # imm = 0x800
movl $0x4, %esi
movb $0x0, %al
callq 0x2110
cmpl $0x0, %eax
jge 0x32cd
leaq 0x42dd(%rip), %rdi      # 0x75a3
movb $0x0, %al
callq 0x2ed0
jmp 0x32cf
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3221
movq 0x10(%rsp), %rsi
movq 0x10(%rsp), %rcx
leaq 0x1840(%rip), %rdi      # 0x4b30
movl $0x68020011, %edx       # imm = 0x68020011
movb $0x0, %al
callq 0x20e0
movl %eax, 0x703e(%rip)      # 0xa340
cmpl $0x0, 0x7037(%rip)      # 0xa340
jge 0x3319
leaq 0x42a3(%rip), %rdi      # 0x75b5
movb $0x0, %al
callq 0x2ed0
cmpl $0x0, 0x7020(%rip)      # 0xa340
jne 0x3330
leaq 0x4296(%rip), %rdi      # 0x75bf
movb $0x0, %al
callq 0x2ed0
callq 0x4be0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: cleanup
static void
cleanup(void)
{
  if (!dir_exists("box"))
    die("Box directory not found, there isn't anything to clean up");

  msg("Deleting sandbox directory\n");
  rmtree(box_dir);
  cg_remove();
}

// Assembly:
pushq %rax
leaq 0x3c21(%rip), %rdi      # 0x6f69
callq 0x42d0
cmpl $0x0, %eax
jne 0x3360
leaq 0x467d(%rip), %rdi      # 0x79d6
movb $0x0, %al
callq 0x2ed0
leaq 0x46a9(%rip), %rdi      # 0x7a10
movb $0x0, %al
callq 0x4090
leaq 0x710b(%rip), %rdi      # 0xa480
callq 0x4330
callq 0x5db0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: xstrdup
static char *
xstrdup(char *str)
{
  char *p = strdup(str);
  if (!p)
    die("Out of memory");
  return p;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2480
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x33be
leaq 0x31c2(%rip), %rdi      # 0x6579
movb $0x0, %al
callq 0x2ed0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: parse_dir_option
static unsigned int parse_dir_option(char *opt)
{
  for (unsigned int i = 0; i < ARRAY_SIZE(dir_flag_names); i++)
    if (!strcmp(opt, dir_flag_names[i]))
      return 1U << i;
  die("Unknown directory option %s", opt);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x5, 0xc(%rsp)
jae 0x3427
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x6966(%rip), %rax      # 0x9d60
movq (%rax,%rcx,8), %rsi
callq 0x22f0
cmpl $0x0, %eax
jne 0x3418
movl 0xc(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
addq $0x18, %rsp
retq
jmp 0x341a
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x33e1
movq 0x10(%rsp), %rsi
leaq 0x3154(%rip), %rdi      # 0x6587
movb $0x0, %al
callq 0x2ed0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: add_dir_rule
static int add_dir_rule(char *in, char *out, unsigned int flags)
{
  // Make sure that "in" is relative
  while (in[0] == '/')
    in++;
  if (!*in)
    return 0;

  // Check "out"
  if (flags & DIR_FLAG_FS)
    {
      if (!out || out[0] == '/')
	return 0;
    }
  else
    {
      if (out && out[0] != '/' && strncmp(out, "./", 2))
	return 0;
    }

  // Override an existing rule
  struct dir_rule *r;
  for (r = first_dir_rule; r; r = r->next)
    if (!strcmp(r->inside, in))
      break;

  // Add a new rule
  if (!r)
    {
      r = xmalloc(sizeof(*r));
      r->inside = in;
      *last_dir_rule = r;
      last_dir_rule = &r->next;
      r->next = NULL;
    }
  r->outside = out;
  r->flags = flags;
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x346f
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x3452
movq 0x18(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x3486
movl $0x0, 0x24(%rsp)
jmp 0x3599
movl 0xc(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x34b6
cmpq $0x0, 0x10(%rsp)
je 0x34a7
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x34b4
movl $0x0, 0x24(%rsp)
jmp 0x3599
jmp 0x34f5
cmpq $0x0, 0x10(%rsp)
je 0x34f3
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x34f3
movq 0x10(%rsp), %rdi
leaq 0x30d3(%rip), %rsi      # 0x65aa
movl $0x2, %edx
callq 0x2080
cmpl $0x0, %eax
je 0x34f3
movl $0x0, 0x24(%rsp)
jmp 0x3599
jmp 0x34f5
movq 0x6e24(%rip), %rax      # 0xa320
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x352f
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x22f0
cmpl $0x0, %eax
jne 0x351f
jmp 0x352f
jmp 0x3521
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
jmp 0x3500
cmpq $0x0, (%rsp)
jne 0x3579
movl $0x20, %edi
callq 0x35b0
movq %rax, (%rsp)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rcx
movq 0x6d0d(%rip), %rax      # 0xa268
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x18, %rax
movq %rax, 0x6cfb(%rip)      # 0xa268
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0xc(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x10(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: xmalloc
static void *
xmalloc(size_t size)
{
  void *p = malloc(size);
  if (!p)
    die("Out of memory");
  return p;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2360
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x35de
leaq 0x2fa2(%rip), %rdi      # 0x6579
movb $0x0, %al
callq 0x2ed0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: meta_printf
static void __attribute__((format(printf,1,2)))
meta_printf(const char *fmt, ...)
{
  if (!metafile)
    return;

  va_list args;
  va_start(args, fmt);
  vfprintf(metafile, fmt, args);
  va_end(args);
}

// Assembly:
subq $0xd8, %rsp
testb %al, %al
je 0x365c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xd0(%rsp)
cmpq $0x0, 0x6cab(%rip)      # 0xa330
jne 0x3689
jmp 0x36d5
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x6c78(%rip), %rdi      # 0xa330
movq 0xd0(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x2440
leaq 0xb0(%rsp), %rax
addq $0xd8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: box_exit
static void NONRET
box_exit(int rc)
{
  if (box_pid > 0)
    {
      kill(-box_pid, SIGKILL);
      kill(box_pid, SIGKILL);
      meta_printf("killed:1\n");

      struct rusage rus;
      int p, stat;
      do
	p = wait4(box_pid, &stat, 0, &rus);
      while (p < 0 && errno == EINTR);
      if (p < 0)
	fprintf(stderr, "UGH: Lost track of the process (%m)\n");
      else
	final_stats(&rus);
    }

  if (rc < 2 && cleanup_ownership)
    {
      chowntree("box", orig_uid, orig_gid);
    }

  meta_close();
  exit(rc);
}

// Assembly:
subq $0xa8, %rsp
movl %edi, 0xa4(%rsp)
cmpl $0x0, 0x6c4b(%rip)      # 0xa340
jle 0x3797
xorl %edi, %edi
subl 0x6c3d(%rip), %edi      # 0xa340
movl $0x9, %esi
callq 0x2340
movl 0x6c2d(%rip), %edi      # 0xa340
movl $0x9, %esi
callq 0x2340
leaq 0x3889(%rip), %rdi      # 0x6fad
movb $0x0, %al
callq 0x3620
movl 0x6c0f(%rip), %edi      # 0xa340
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
leaq 0x10(%rsp), %rcx
callq 0x23f0
movl %eax, 0xc(%rsp)
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
movb %al, 0x7(%rsp)
jge 0x3762
callq 0x2060
cmpl $0x4, (%rax)
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x372b
cmpl $0x0, 0xc(%rsp)
jge 0x378b
movq 0x6880(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x3835(%rip), %rsi      # 0x6fb7
movb $0x0, %al
callq 0x2300
jmp 0x3795
leaq 0x10(%rsp), %rdi
callq 0x37e0
jmp 0x3797
cmpl $0x2, 0xa4(%rsp)
jge 0x37c2
cmpl $0x0, 0x6b9c(%rip)      # 0xa344
je 0x37c2
movl 0x6b68(%rip), %esi      # 0xa318
movl 0x6b66(%rip), %edx      # 0xa31c
leaq 0x37ac(%rip), %rdi      # 0x6f69
callq 0x38b0
callq 0x3900
movl 0xa4(%rsp), %edi
callq 0x2470
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: final_stats
static void
final_stats(struct rusage *rus)
{
  total_ms = get_run_time_ms(rus);
  wall_ms = get_wall_time_ms();

  meta_printf("time:%d.%03d\n", total_ms/1000, total_ms%1000);
  meta_printf("time-wall:%d.%03d\n", wall_ms/1000, wall_ms%1000);
  meta_printf("max-rss:%ld\n", rus->ru_maxrss);
  meta_printf("csw-voluntary:%ld\n", rus->ru_nvcsw);
  meta_printf("csw-forced:%ld\n", rus->ru_nivcsw);

  cg_stats();
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x3930
movl %eax, 0x6b54(%rip)      # 0xa348
callq 0x3bc0
movl %eax, 0x6b4d(%rip)      # 0xa34c
movl 0x6b43(%rip), %eax      # 0xa348
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movl %eax, %esi
movl 0x6b33(%rip), %eax      # 0xa348
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
leaq 0x37b8(%rip), %rdi      # 0x6fdc
movb $0x0, %al
callq 0x3620
movl 0x6b1b(%rip), %eax      # 0xa34c
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movl %eax, %esi
movl 0x6b0b(%rip), %eax      # 0xa34c
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
leaq 0x379a(%rip), %rdi      # 0x6fea
movb $0x0, %al
callq 0x3620
movq (%rsp), %rax
movq 0x20(%rax), %rsi
leaq 0x3797(%rip), %rdi      # 0x6ffd
movb $0x0, %al
callq 0x3620
movq (%rsp), %rax
movq 0x80(%rax), %rsi
leaq 0x378b(%rip), %rdi      # 0x700a
movb $0x0, %al
callq 0x3620
movq (%rsp), %rax
movq 0x88(%rax), %rsi
leaq 0x3785(%rip), %rdi      # 0x701d
movb $0x0, %al
callq 0x3620
callq 0x3c50
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: cg_stats
static void
cg_stats(void)
{
  if (!cg_enable)
    return;

  char buf[CG_BUFSIZE];

  // Memory usage statistics
  unsigned long long mem=0, memsw=0;
  if (cg_read(CG_MEMORY, "?memory.max_usage_in_bytes", buf))
    mem = atoll(buf);
  if (cg_read(CG_MEMORY, "?memory.memsw.max_usage_in_bytes", buf))
    {
      memsw = atoll(buf);
      if (memsw > mem)
	mem = memsw;
    }
  if (mem)
    meta_printf("cg-mem:%lld\n", mem >> 10);
}

// Assembly:
subq $0x418, %rsp            # imm = 0x418
cmpl $0x0, 0x6662(%rip)      # 0xa2c0
jne 0x3c65
jmp 0x3cf8
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
leaq 0x10(%rsp), %rdx
xorl %edi, %edi
leaq 0x34cf(%rip), %rsi      # 0x7153
callq 0x3e60
cmpl $0x0, %eax
je 0x3c9d
leaq 0x10(%rsp), %rdi
callq 0x22e0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdx
xorl %edi, %edi
leaq 0x34c3(%rip), %rsi      # 0x716e
callq 0x3e60
cmpl $0x0, %eax
je 0x3cd9
leaq 0x10(%rsp), %rdi
callq 0x22e0
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0x3cd7
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x3cd9
cmpq $0x0, 0x8(%rsp)
je 0x3cf8
movq 0x8(%rsp), %rsi
shrq $0xa, %rsi
leaq 0x349e(%rip), %rdi      # 0x718f
movb $0x0, %al
callq 0x3620
addq $0x418, %rsp            # imm = 0x418
retq
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: cg_get_run_time_ms
static int
cg_get_run_time_ms(void)
{
  if (!cg_enable)
    return 0;

  char buf[CG_BUFSIZE];
  cg_read(CG_CPUACCT, "cpuacct.usage", buf);
  unsigned long long ns = atoll(buf);
  return ns / 1000000;
}

// Assembly:
subq $0x418, %rsp            # imm = 0x418
cmpl $0x0, 0x65b2(%rip)      # 0xa2c0
jne 0x3d1d
movl $0x0, 0x414(%rsp)
jmp 0x3d58
leaq 0x10(%rsp), %rdx
movl $0x1, %edi
leaq 0x3368(%rip), %rsi      # 0x7096
callq 0x3e60
leaq 0x10(%rsp), %rdi
callq 0x22e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
xorl %edx, %edx
divq %rcx
movl %eax, 0x414(%rsp)
movl 0x414(%rsp), %eax
addq $0x418, %rsp            # imm = 0x418
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: read_proc_file
static void
read_proc_file(char *buf, char *name, int *fdp)
{
  int c;

  if (!*fdp)
    {
      sprintf(buf, "/proc/%d/%s", (int) box_pid, name);
      *fdp = open(buf, O_RDONLY);
      if (*fdp < 0)
	die("open(%s): %m", buf);
    }
  lseek(*fdp, 0, SEEK_SET);
  if ((c = read(*fdp, buf, PROC_BUF_SIZE-1)) < 0)
    die("read on /proc/$pid/%s: %m", name);
  if (c >= PROC_BUF_SIZE-1)
    die("/proc/$pid/%s too long", name);
  buf[c] = 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x3de1
movq 0x20(%rsp), %rdi
movl 0x65a8(%rip), %edx      # 0xa340
movq 0x18(%rsp), %rcx
leaq 0x3365(%rip), %rsi      # 0x7109
movb $0x0, %al
callq 0x2460
movq 0x20(%rsp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x2400
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
jge 0x3ddf
movq 0x20(%rsp), %rsi
leaq 0x333d(%rip), %rdi      # 0x7115
movb $0x0, %al
callq 0x2ed0
jmp 0x3de1
movq 0x10(%rsp), %rax
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2220
movq 0x10(%rsp), %rax
movl (%rax), %edi
movq 0x20(%rsp), %rsi
movl $0xfff, %edx            # imm = 0xFFF
callq 0x22c0
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
jge 0x3e25
movq 0x18(%rsp), %rsi
leaq 0x3304(%rip), %rdi      # 0x7122
movb $0x0, %al
callq 0x2ed0
cmpl $0xfff, 0xc(%rsp)       # imm = 0xFFF
jl 0x3e42
movq 0x18(%rsp), %rsi
leaq 0x3301(%rip), %rdi      # 0x713c
movb $0x0, %al
callq 0x2ed0
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: cg_read
static int
cg_read(cg_controller controller, const char *attr, char *buf)
{
  int maybe = 0;
  if (attr[0] == '?')
    {
      attr++;
      maybe = 1;
    }

  char path[256];
  cg_makepath(path, sizeof(path), controller, attr);

  int fd = open(path, O_RDONLY);
  if (fd < 0)
    {
      if (maybe)
	return 0;
      die("Cannot read %s: %m", path);
    }

  int n = read(fd, buf, CG_BUFSIZE);
  if (n < 0)
    {
      if (maybe)
	return 0;
      die("Cannot read %s: %m", path);
    }
  if (n >= CG_BUFSIZE - 1)
    die("Attribute %s too long", path);
  if (n > 0 && buf[n-1] == '\n')
    n--;
  buf[n] = 0;

  if (verbose > 1)
    msg("CG: Read %s = %s\n", attr, buf);

  close(fd);
  return 1;
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movl %edi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movl $0x0, 0x11c(%rsp)
movq 0x128(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3f, %eax
jne 0x3eb8
movq 0x128(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x128(%rsp)
movl $0x1, 0x11c(%rsp)
leaq 0x10(%rsp), %rdi
movl 0x130(%rsp), %edx
movq 0x128(%rsp), %rcx
movl $0x100, %esi            # imm = 0x100
callq 0x4010
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x2400
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x3f1c
cmpl $0x0, 0x11c(%rsp)
je 0x3f09
movl $0x0, 0x134(%rsp)
jmp 0x4000
leaq 0x10(%rsp), %rsi
leaq 0x318f(%rip), %rdi      # 0x70a4
movb $0x0, %al
callq 0x2ed0
movl 0xc(%rsp), %edi
movq 0x120(%rsp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x22c0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jge 0x3f6a
cmpl $0x0, 0x11c(%rsp)
je 0x3f57
movl $0x0, 0x134(%rsp)
jmp 0x4000
leaq 0x10(%rsp), %rsi
leaq 0x3141(%rip), %rdi      # 0x70a4
movb $0x0, %al
callq 0x2ed0
cmpl $0x3ff, 0x8(%rsp)       # imm = 0x3FF
jl 0x3f87
leaq 0x10(%rsp), %rsi
leaq 0x3137(%rip), %rdi      # 0x70b7
movb $0x0, %al
callq 0x2ed0
cmpl $0x0, 0x8(%rsp)
jle 0x3fb4
movq 0x120(%rsp), %rax
movl 0x8(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x3fb4
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
movq 0x120(%rsp), %rax
movslq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x1, 0x6330(%rip)      # 0xa2fc
jle 0x3fec
movq 0x128(%rsp), %rsi
movq 0x120(%rsp), %rdx
leaq 0x30e8(%rip), %rdi      # 0x70cd
movb $0x0, %al
callq 0x4090
movl 0xc(%rsp), %edi
callq 0x2280
movl $0x1, 0x134(%rsp)
movl 0x134(%rsp), %eax
addq $0x138, %rsp            # imm = 0x138
retq
nop
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: msg
static void __attribute__((format(printf,1,2)))
msg(char *msg, ...)
{
  va_list args;
  va_start(args, msg);
  if (verbose)
    {
      int len = strlen(msg);
      if (len > 0)
        partial_line = (msg[len-1] != '\n');
      vfprintf(stderr, msg, args);
      fflush(stderr);
    }
  va_end(args);
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x40cc
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xe0(%rsp)
leaq 0xc0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
cmpl $0x0, 0x61e0(%rip)      # 0xa2fc
je 0x4194
movq 0xe0(%rsp), %rdi
callq 0x2180
movl %eax, 0xbc(%rsp)
cmpl $0x0, 0xbc(%rsp)
jle 0x4166
movq 0xe0(%rsp), %rax
movl 0xbc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x61d6(%rip)      # 0xa33c
movq 0x5e8b(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq 0xe0(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x2440
movq 0x5e6c(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
callq 0x2370
addq $0xe8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: make_dir
static void make_dir(char *path)
{
  char *sep = (path[0] == '/' ? path+1 : path);

  for (;;)
    {
      sep = strchr(sep, '/');
      if (sep)
	*sep = 0;

      if (!dir_exists(path) && mkdir(path, 0777) < 0)
	die("Cannot create directory %s: %m\n", path);

      if (!sep)
	return;
      *sep++ = '/';
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x4235
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x423e
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x2f, %esi
callq 0x21f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x426b
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rdi
callq 0x42d0
cmpl $0x0, %eax
jne 0x42a1
movq 0x10(%rsp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x20b0
cmpl $0x0, %eax
jge 0x42a1
movq 0x10(%rsp), %rsi
leaq 0x2f52(%rip), %rdi      # 0x71ec
movb $0x0, %al
callq 0x2ed0
cmpq $0x0, 0x8(%rsp)
jne 0x42ae
addq $0x18, %rsp
retq
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movb $0x2f, (%rax)
jmp 0x4247
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: cg_prepare
static void
cg_prepare(void)
{
  if (!cg_enable)
    return;

  struct stat st;
  char buf[CG_BUFSIZE];
  char path[256];

  FOREACH_CG_CONTROLLER(controller)
    {
      cg_makepath(path, sizeof(path), controller, "");
      if (stat(path, &st) >= 0 || errno != ENOENT)
	{
	  msg("Control group %s already exists, trying to empty it.\n", path);
	  if (rmdir(path) < 0)
	    die("Failed to reset control group %s: %m", path);
	}

      if (mkdir(path, 0777) < 0 && !cg_controller_optional(controller))
	die("Failed to create control group %s: %m", path);
    }

  // If cpuset module is enabled, copy allowed cpus and memory nodes from parent group
  if (cg_read(CG_CPUSET, "?cpuset.cpus", buf))
    cg_write(CG_CPUSET, "cpuset.cpus", "%s", buf);
  if (cg_read(CG_CPUSET, "?cpuset.mems", buf))
    cg_write(CG_CPUSET, "cpuset.mems", "%s", buf);
}

// Assembly:
subq $0x5a8, %rsp            # imm = 0x5A8
cmpl $0x0, 0x5f52(%rip)      # 0xa2c0
jne 0x4375
jmp 0x44c1
movl $0x0, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
jae 0x4441
leaq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0x100, %esi            # imm = 0x100
leaq 0x3583(%rip), %rcx      # 0x7920
callq 0x4010
leaq 0x10(%rsp), %rdi
leaq 0x518(%rsp), %rsi
callq 0x2320
cmpl $0x0, %eax
jge 0x43c3
callq 0x2060
cmpl $0x2, (%rax)
je 0x43fa
leaq 0x10(%rsp), %rsi
leaq 0x2ef8(%rip), %rdi      # 0x72c7
movb $0x0, %al
callq 0x4090
leaq 0x10(%rsp), %rdi
callq 0x2170
cmpl $0x0, %eax
jge 0x43f8
leaq 0x10(%rsp), %rsi
leaq 0x2f0c(%rip), %rdi      # 0x72fd
movb $0x0, %al
callq 0x2ed0
jmp 0x43fa
leaq 0x10(%rsp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x20b0
cmpl $0x0, %eax
jge 0x442f
movl 0xc(%rsp), %edi
callq 0x4750
cmpl $0x0, %eax
jne 0x442f
leaq 0x10(%rsp), %rsi
leaq 0x2efa(%rip), %rdi      # 0x7322
movb $0x0, %al
callq 0x2ed0
jmp 0x4431
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x437d
leaq 0x110(%rsp), %rdx
movl $0x2, %edi
leaq 0x2ef3(%rip), %rsi      # 0x7348
callq 0x3e60
cmpl $0x0, %eax
je 0x4481
leaq 0x110(%rsp), %rcx
movl $0x2, %edi
leaq 0x2ed6(%rip), %rsi      # 0x7349
leaq 0x2f24(%rip), %rdx      # 0x739e
movb $0x0, %al
callq 0x4770
leaq 0x110(%rsp), %rdx
movl $0x2, %edi
leaq 0x2ec0(%rip), %rsi      # 0x7355
callq 0x3e60
cmpl $0x0, %eax
je 0x44c1
leaq 0x110(%rsp), %rcx
movl $0x2, %edi
leaq 0x2ea3(%rip), %rsi      # 0x7356
leaq 0x2ee4(%rip), %rdx      # 0x739e
movb $0x0, %al
callq 0x4770
addq $0x5a8, %rsp            # imm = 0x5A8
retq
nopl (%rax)