LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/threads.c
// Function: preempt_thread
static void preempt_thread(struct thread *thread)
{
	if (thread == &bootstrap)
		return;

	if (scheduler->preempt)
		scheduler->preempt(thread);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x32a00d(%rip), %rax    # 0xffffffff80433000
cmpq %rax, -0x8(%rbp)
jne 0xffffffff80108ffb
jmp 0xffffffff8010901a
movq 0x32a05e(%rip), %rax    # 0xffffffff80433060
cmpq $0x0, 0x28(%rax)
je 0xffffffff8010901a
movq 0x32a050(%rip), %rax    # 0xffffffff80433060
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/threads.c
// Function: setup_tss_desc
static void setup_tss_desc(struct tss_desc *desc, struct tss *tss)
{
	const uint64_t limit = sizeof(*tss) - 1;
	const uint64_t base = (uint64_t)tss;

	desc->low = (limit & BITS_CONST(15, 0))
			| ((base & BITS_CONST(23, 0)) << 16)
			| (((uint64_t)9 | BIT_CONST(7)) << 40)
			| ((limit & BITS_CONST(19, 16)) << 32)
			| ((base & BITS_CONST(31, 24)) << 32);
	desc->high = base >> 32;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x1006f, -0x18(%rbp) # imm = 0x1006F
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
andq $0xffffff, %rcx         # imm = 0xFFFFFF
shlq $0x10, %rcx
orq $0x6f, %rcx
movabsq $0x890000000000, %rax # imm = 0x890000000000
orq %rax, %rcx
movabsq $0x1000000000000, %rax # imm = 0x1000000000000
orq %rax, %rcx
movabsq $0xff000000, %rax # imm = 0xFF000000
andq -0x20(%rbp), %rax
shlq $0x20, %rax
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
shrq $0x20, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/time.c
// Function: i8254_set_frequency
static void i8254_set_frequency(unsigned long freq)
{
	const unsigned long divisor = i8254_divisor(freq);
	const unsigned char cmd = I8254_SELECT_CH0 | I8254_HILO_BYTES
				| I8254_RATE_GEN | I8254_SELECT_CH0;

	out8(I8254_CTRL_PORT, cmd);
	out8(I8254_CH0_DATA_PORT, divisor & BITS(7, 0));
	out8(I8254_CH0_DATA_PORT, (divisor & BITS(15, 8)) >> 8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xffffffff80109190
movq %rax, -0x10(%rbp)
movb $0x34, -0x11(%rbp)
movl $0x43, %edi
movl $0x34, %esi
callq 0xffffffff801091b0
movq -0x10(%rbp), %rax
andq $0xff, %rax
movl $0x40, %edi
movzbl %al, %esi
callq 0xffffffff801091b0
movq -0x10(%rbp), %rax
andq $0xff00, %rax           # imm = 0xFF00
shrq $0x8, %rax
movl $0x40, %edi
movzbl %al, %esi
callq 0xffffffff801091b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/scheduler.c
// Function: rr_alloc_thread
static struct thread *rr_alloc_thread(void)
{
	struct rr_thread *thread = kmem_cache_alloc(rr_thread_cache);

	if (!thread)
		return 0;

	list_init(&thread->link);

	return THREAD(thread);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x33aea9(%rip), %rdi    # 0xffffffff80444088
callq 0xffffffff80106fd0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xffffffff801091f9
movq $0x0, -0x8(%rbp)
jmp 0xffffffff80109213
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0xffffffff80101190
movq -0x10(%rbp), %rdi
callq 0xffffffff801094c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/scheduler.c
// Function: rr_next_thread
static struct thread *rr_next_thread(void)
{
	DBG_ASSERT(local_preempt_disabled());

	if (list_empty(&rr_active_list))
		return 0;

	struct list_head *first = list_first(&rr_active_list);
	struct rr_thread *thread = LIST_ENTRY(first, struct rr_thread, link);

	list_del(&thread->link);

	return THREAD(thread);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xffffffff801094e0
testb $0x1, %al
jne 0xffffffff80109380
leaq 0x8e21(%rip), %rdi      # 0xffffffff80112179
leaq 0x9406(%rip), %rsi      # 0xffffffff80112765
movl $0x35, %edx
leaq 0x8e12(%rip), %rcx      # 0xffffffff8011217d
leaq 0x9435(%rip), %r8       # 0xffffffff801127a7
movb $0x0, %al
callq 0xffffffff80101e60
callq 0xffffffff80111cd0
jmp 0xffffffff8010937e
jmp 0xffffffff80109382
leaq 0xe91f(%rip), %rdi      # 0xffffffff80117ca8
callq 0xffffffff801012f0
testb $0x1, %al
jne 0xffffffff80109394
jmp 0xffffffff8010939e
movq $0x0, -0x8(%rbp)
jmp 0xffffffff801093d4
leaq 0xe903(%rip), %rdi      # 0xffffffff80117ca8
callq 0xffffffff80101370
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $-0x58, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
callq 0xffffffff80101250
movq -0x18(%rbp), %rdi
callq 0xffffffff801094c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_entry_detach
void vfs_entry_detach(struct fs_entry *entry)
{
	struct fs_entry *parent = entry->parent;
	const bool enabled = spin_lock_irqsave(&parent->lock);
	__vfs_entry_detach(entry, parent);
	spin_unlock_irqrestore(&parent->lock, enabled);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0xffffffff80109590
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xffffffff801095b0
movq -0x10(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xffffffff801095f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_entry_get
struct fs_entry *vfs_entry_get(struct fs_entry *entry)
{
	if (entry) {	
		const bool enabled = spin_lock_irqsave(&entry->lock);
		++entry->refcount;
		spin_unlock_irqrestore(&entry->lock, enabled);
	}
	return entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xffffffff80109673
movq -0x8(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0xffffffff80109590
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x140(%rax)
movq -0x8(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xffffffff801095f0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_entry_put
void vfs_entry_put(struct fs_entry *entry)
{
	struct fs_entry *dir = entry->parent;

	const bool enabled = spin_lock_irqsave(&entry->lock);
	const int refcount = --entry->refcount;
	spin_unlock_irqrestore(&entry->lock, enabled);

	if (refcount != 0)
		return;

	spin_lock(&dir->lock);
	spin_lock(&entry->lock);

	if (entry->refcount) {
		spin_unlock_irqrestore(&entry->lock, false);
		spin_unlock_irqrestore(&dir->lock, enabled);
		return;
	}
	__vfs_entry_detach(entry, dir);

	spin_unlock_irqrestore(&entry->lock, false);
	spin_unlock_irqrestore(&dir->lock, enabled);

	vfs_entry_put(entry->parent);
	vfs_node_put(entry->node);
	kmem_cache_free(fs_entry_cache, entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0xffffffff80109590
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rcx
movl 0x140(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x140(%rcx)
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xffffffff801095f0
cmpl $0x0, -0x18(%rbp)
je 0xffffffff801096e6
jmp 0xffffffff801097a0
movq -0x10(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0xffffffff801097b0
movq -0x8(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0xffffffff801097b0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x140(%rax)
je 0xffffffff8010973f
movq -0x8(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
xorl %esi, %esi
callq 0xffffffff801095f0
movq -0x10(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xffffffff801095f0
jmp 0xffffffff801097a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xffffffff801095b0
movq -0x8(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
xorl %esi, %esi
callq 0xffffffff801095f0
movq -0x10(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xffffffff801095f0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xffffffff80109680
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xffffffff801097d0
movq 0x33a8f9(%rip), %rdi    # 0xffffffff80444090
movq -0x8(%rbp), %rsi
callq 0xffffffff80107260
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/./vfs.h
// Function: vfs_node_put
static inline void vfs_node_put(struct fs_node *node)
{
	if (!node)
		return;

	const bool enabled = spin_lock_irqsave(&node->lock);
	const int refcount = --node->refcount;
	spin_unlock_irqrestore(&node->lock, enabled);

	if (!refcount)
		vfs_node_destroy(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xffffffff801097e5
jmp 0xffffffff8010982b
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0xffffffff80109590
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rcx
movl 0x38(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x38(%rcx)
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xffffffff801095f0
cmpl $0x0, -0x10(%rbp)
jne 0xffffffff8010982b
movq -0x8(%rbp), %rdi
callq 0xffffffff80109840
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_release
int vfs_release(struct fs_file *file)
{
	if (file->ops && file->ops->release) {
		const int ret = file->ops->release(file);

		if (ret)
			return ret;
	}

	vfs_file_cleanup(file);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xffffffff80109b2b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0xffffffff80109b2b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xffffffff80109b29
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xffffffff80109b3b
jmp 0xffffffff80109b2b
movq -0x10(%rbp), %rdi
callq 0xffffffff80109b50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_file_cleanup
static void vfs_file_cleanup(struct fs_file *file)
{
	if (file->entry)
		vfs_entry_put(file->entry);

	file->entry = 0;
	file->node = 0;
	file->ops = 0;
	file->offset = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xffffffff80109b72
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xffffffff80109680
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_seek_default
int vfs_seek_default(struct fs_file *file, int offset, int whence)
{
	switch (whence) {
	case FSS_CUR:
		offset += file->offset;
		break;
	case FSS_END:
		offset += file->node->size;
		break;
	}

	offset = MAX(offset, 0);
	file->offset = offset;
	return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0xffffffff80109c99
jmp 0xffffffff80109c8f
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0xffffffff80109ca8
jmp 0xffffffff80109cb9
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xffffffff80109cb9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x3c(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xffffffff80109ce0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_readdir
int vfs_readdir(struct fs_file *file, struct dirent *entries, size_t count)
{
	if (file->ops && file->ops->iterate) {
		struct readdir_ctx ctx;

		ctx.ctx.emit = &readdir_next_entry;
		ctx.ctx.offset = file->offset;
		ctx.entries = entries;
		ctx.count = count;
		ctx.pos = 0;

		const int rc = file->ops->iterate(file, &ctx.ctx);

		if (file->offset != ctx.ctx.offset) {
			const int ret = ctx.ctx.offset - file->offset;

			file->offset = ctx.ctx.offset;
			return ret;
		}
		return rc;
	}

	return -ENOTSUP;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xffffffff80109e1b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0xffffffff80109e1b
leaq 0x87(%rip), %rax        # 0xffffffff80109e30
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq *%rax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x40(%rbp), %eax
je 0xffffffff80109e13
movl -0x40(%rbp), %eax
movq -0x10(%rbp), %rcx
subl 0x18(%rcx), %eax
movl %eax, -0x50(%rbp)
movl -0x40(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x50(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xffffffff80109e22
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xffffffff80109e22
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: readdir_next_entry
static bool readdir_next_entry(struct dir_iter_ctx *ctx, const char *name,
			size_t len)
{
	struct readdir_ctx *rdctx = (struct readdir_ctx *)ctx;
	struct dirent *entries = rdctx->entries;
	size_t count = rdctx->count;
	size_t pos = rdctx->pos;

	if (pos != count) {
		memset(entries[pos].name, 0, MAX_PATH_LEN);
		strncpy(entries[pos].name, name, MINU(MAX_PATH_LEN - 1, len));
		++rdctx->pos;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0xffffffff80109ee4
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rax
shlq $0x8, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0xffffffff801017e0
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rsi
movl $0xff, %edi
callq 0xffffffff8010acb0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0xffffffff801019f0
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xffffffff80109ee8
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_resolve_path
static struct fs_entry *vfs_resolve_path(const char *path, int *rc)
{
	struct vfs_walk_data wd;

	vfs_walk_start(&wd, path);
	*rc = vfs_walk_all(&wd);
	if (*rc) {
		vfs_walk_stop(&wd);
		return 0;
	}

	struct fs_entry *entry = vfs_entry_get(wd.entry);

	vfs_walk_stop(&wd);
	*rc = 0;
	return entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x128(%rbp), %rdi
callq 0xffffffff8010a1a0
leaq -0x128(%rbp), %rdi
callq 0xffffffff8010ace0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0xffffffff8010a156
leaq -0x128(%rbp), %rdi
callq 0xffffffff8010a260
movq $0x0, -0x8(%rbp)
jmp 0xffffffff8010a18a
movq -0x128(%rbp), %rdi
callq 0xffffffff80109620
movq %rax, -0x130(%rbp)
leaq -0x128(%rbp), %rdi
callq 0xffffffff8010a260
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x130(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_walk_parent
static int vfs_walk_parent(struct vfs_walk_data *data)
{
	while (strcmp(data->tail, "")) {
		const int rc = vfs_walk(data);

		if (rc)
			return rc;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rdi
leaq 0x8c53(%rip), %rsi      # 0xffffffff80112e71
callq 0xffffffff80101980
cmpl $0x0, %eax
je 0xffffffff8010a244
movq -0x10(%rbp), %rdi
callq 0xffffffff8010ad40
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xffffffff8010a242
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xffffffff8010a24b
jmp 0xffffffff8010a20c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_unlink
int vfs_unlink(const char *name)
{
	int rc;
	struct fs_entry *entry = vfs_resolve_path(name, &rc);

	if (!entry)
		return rc;

	struct fs_entry *dir = entry->parent;
	struct fs_node *node = dir->node;

	if (!node->ops->unlink) {
		vfs_entry_put(entry);
		return -ENOTSUP;
	}

	mutex_lock(&node->mux);
	rc = node->ops->unlink(node, entry);
	mutex_unlock(&node->mux);
	vfs_entry_put(entry);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0xffffffff8010a100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xffffffff8010a4bc
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xffffffff8010a52f
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0xffffffff8010a4f5
movq -0x20(%rbp), %rdi
callq 0xffffffff80109680
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xffffffff8010a52f
movq -0x30(%rbp), %rdi
callq 0xffffffff8010dff0
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movl %eax, -0x14(%rbp)
movq -0x30(%rbp), %rdi
callq 0xffffffff8010e140
movq -0x20(%rbp), %rdi
callq 0xffffffff80109680
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_mkdir
int vfs_mkdir(const char *name)
{
	struct vfs_walk_data wd;
	int rc;

	vfs_walk_start(&wd, name);
	rc = vfs_walk_parent(&wd);
	if (rc) {
		vfs_walk_stop(&wd);
		return rc;
	}

	struct fs_entry *dir = wd.entry;
	struct fs_node *node = dir->node;

	if (!node->ops->lookup || !node->ops->mkdir) {
		vfs_walk_stop(&wd);
		return -ENOTSUP;
	}

	mutex_lock(&node->mux);
	struct fs_entry *entry = vfs_lookup(dir, wd.next, true, &rc);

	if (!entry) {
		mutex_unlock(&node->mux);
		vfs_walk_stop(&wd);
		return rc;
	}

	if (entry->node) {
		mutex_unlock(&node->mux);
		vfs_walk_stop(&wd);
		vfs_entry_put(entry);
		return -EEXIST;
	}

	rc = node->ops->mkdir(node, entry);
	mutex_unlock(&node->mux);
	vfs_walk_stop(&wd);
	vfs_entry_put(entry);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0xffffffff8010a1a0
leaq -0x120(%rbp), %rdi
callq 0xffffffff8010a200
movl %eax, -0x124(%rbp)
cmpl $0x0, -0x124(%rbp)
je 0xffffffff8010a594
leaq -0x120(%rbp), %rdi
callq 0xffffffff8010a260
movl -0x124(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xffffffff8010a6e3
movq -0x120(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x138(%rbp)
movq -0x138(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0xffffffff8010a5d8
movq -0x138(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0xffffffff8010a5f0
leaq -0x120(%rbp), %rdi
callq 0xffffffff8010a260
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xffffffff8010a6e3
movq -0x138(%rbp), %rdi
callq 0xffffffff8010dff0
movq -0x130(%rbp), %rdi
leaq -0x120(%rbp), %rsi
addq $0x8, %rsi
movl $0x1, %edx
leaq -0x124(%rbp), %rcx
callq 0xffffffff8010a290
movq %rax, -0x140(%rbp)
cmpq $0x0, -0x140(%rbp)
jne 0xffffffff8010a656
movq -0x138(%rbp), %rdi
callq 0xffffffff8010e140
leaq -0x120(%rbp), %rdi
callq 0xffffffff8010a260
movl -0x124(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xffffffff8010a6e3
movq -0x140(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xffffffff8010a691
movq -0x138(%rbp), %rdi
callq 0xffffffff8010e140
leaq -0x120(%rbp), %rdi
callq 0xffffffff8010a260
movq -0x140(%rbp), %rdi
callq 0xffffffff80109680
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xffffffff8010a6e3
movq -0x138(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movq -0x138(%rbp), %rdi
movq -0x140(%rbp), %rsi
callq *%rax
movl %eax, -0x124(%rbp)
movq -0x138(%rbp), %rdi
callq 0xffffffff8010e140
leaq -0x120(%rbp), %rdi
callq 0xffffffff8010a260
movq -0x140(%rbp), %rdi
callq 0xffffffff80109680
movl -0x124(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_rmdir
int vfs_rmdir(const char *name)
{
	int rc;
	struct fs_entry *entry = vfs_resolve_path(name, &rc);

	if (!entry)
		return rc;

	struct fs_entry *parent = entry->parent;
	struct fs_node *node = parent->node;

	if (!node->ops->rmdir) {
		vfs_entry_put(entry);
		return -ENOTSUP;
	}

	mutex_lock(&node->mux);
	rc = node->ops->rmdir(node, entry);
	mutex_unlock(&node->mux);
	vfs_entry_put(entry);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0xffffffff8010a100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xffffffff8010a71c
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xffffffff8010a78f
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0xffffffff8010a755
movq -0x20(%rbp), %rdi
callq 0xffffffff80109680
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xffffffff8010a78f
movq -0x30(%rbp), %rdi
callq 0xffffffff8010dff0
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movl %eax, -0x14(%rbp)
movq -0x30(%rbp), %rdi
callq 0xffffffff8010e140
movq -0x20(%rbp), %rdi
callq 0xffffffff80109680
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: register_filesystem
int register_filesystem(struct fs_type *type)
{
	mutex_lock(&fs_root_node.mux);
	if (__vfs_lookup_filesystem(type->name)) {
		mutex_unlock(&fs_root_node.mux);
		return -EEXIST;
	}
	list_add_tail(&type->link, &fs_types);
	mutex_unlock(&fs_root_node.mux);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x3398e5(%rip), %rdi    # 0xffffffff80444098
callq 0xffffffff8010dff0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xffffffff8010a810
cmpq $0x0, %rax
je 0xffffffff8010a7e0
leaq 0x3398c6(%rip), %rdi    # 0xffffffff80444098
callq 0xffffffff8010e140
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xffffffff8010a803
movq -0x10(%rbp), %rdi
leaq 0xd4cd(%rip), %rsi      # 0xffffffff80117cb8
callq 0xffffffff80101220
leaq 0x3398a1(%rip), %rdi    # 0xffffffff80444098
callq 0xffffffff8010e140
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: _vfs_lookup_filesystem
static struct fs_type *__vfs_lookup_filesystem(const char *name)
{
	struct list_head *head = &fs_types;
	struct list_head *ptr = head->next;

	for (; ptr != head; ptr = ptr->next) {
		struct fs_type *fs = LIST_ENTRY(ptr, struct fs_type, link);

		if (!strcmp(fs->name, name))
			return fs;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xd495(%rip), %rax      # 0xffffffff80117cb8
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xffffffff8010a873
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xffffffff80101980
cmpl $0x0, %eax
jne 0xffffffff8010a864
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xffffffff8010a87b
jmp 0xffffffff8010a866
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xffffffff8010a832
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: unregister_filesystem
int unregister_filesystem(struct fs_type *type)
{
	mutex_lock(&fs_root_node.mux);
	if (type->refcount) {
		mutex_unlock(&fs_root_node.mux);
		return -EBUSY;
	}
	list_del(&type->link);
	mutex_unlock(&fs_root_node.mux);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x3397f5(%rip), %rdi    # 0xffffffff80444098
callq 0xffffffff8010dff0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0xffffffff8010a8c7
leaq 0x3397df(%rip), %rdi    # 0xffffffff80444098
callq 0xffffffff8010e140
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0xffffffff8010a8e3
movq -0x10(%rbp), %rdi
callq 0xffffffff80101250
leaq 0x3397c1(%rip), %rdi    # 0xffffffff80444098
callq 0xffffffff8010e140
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_mount
int vfs_mount(const char *fs_name, const char *mount, const void *data,
			size_t size)
{
	mutex_lock(&fs_root_node.mux);
	const int rc = __vfs_mount(fs_name, mount, data, size);
	mutex_unlock(&fs_root_node.mux);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x339789(%rip), %rdi    # 0xffffffff80444098
callq 0xffffffff8010dff0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xffffffff8010a950
movl %eax, -0x24(%rbp)
leaq 0x339765(%rip), %rdi    # 0xffffffff80444098
callq 0xffffffff8010e140
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: _vfs_mount
static int __vfs_mount(const char *fs_name, const char *mount, const void *data,
			size_t size)
{
	struct fs_type *fs = __vfs_lookup_filesystem(fs_name);

	if (!fs)
		return -ENOENT;

	if (__vfs_lookup_mount(mount))
		return -EEXIST;

	struct fs_mount *mnt = __vfs_mount_create(fs, mount);

	if (!mnt)
		return -ENOMEM;

	const int ret = fs->ops->mount(mnt, data, size);

	if (ret) {
		__vfs_mount_destroy(mnt->fs, mnt);
		return ret;
	}

	list_add_tail(&mnt->link, &fs_mounts);
	++fs->refcount;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xffffffff8010a810
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xffffffff8010a988
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xffffffff8010aa23
movq -0x18(%rbp), %rdi
callq 0xffffffff8010b080
cmpq $0x0, %rax
je 0xffffffff8010a9a3
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xffffffff8010aa23
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xffffffff8010b100
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xffffffff8010a9c4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xffffffff8010aa23
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0xffffffff8010aa00
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0xffffffff8010b180
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xffffffff8010aa23
movq -0x38(%rbp), %rdi
leaq 0xd325(%rip), %rsi      # 0xffffffff80117d30
callq 0xffffffff80101220
movq -0x30(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_umount
int vfs_umount(const char *mount)
{
	mutex_lock(&fs_root_node.mux);
	const int rc = __vfs_umount(mount);
	mutex_unlock(&fs_root_node.mux);
	return rc;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x339655(%rip), %rdi    # 0xffffffff80444098
callq 0xffffffff8010dff0
movq -0x8(%rbp), %rdi
callq 0xffffffff8010aa70
movl %eax, -0xc(%rbp)
leaq 0x33963d(%rip), %rdi    # 0xffffffff80444098
callq 0xffffffff8010e140
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: _vfs_umount
static int __vfs_umount(const char *mount)
{
	struct fs_mount *mnt = __vfs_lookup_mount(mount);

	if (!mnt)
		return -ENOENT;

	list_del(&mnt->link);
	mnt->fs->ops->umount(mnt);
	--mnt->fs->refcount;
	__vfs_mount_destroy(mnt->fs, mnt);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xffffffff8010b080
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xffffffff8010aa99
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xffffffff8010aae1
movq -0x18(%rbp), %rdi
callq 0xffffffff80101250
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xffffffff8010b180
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: setup_vfs
void setup_vfs(void)
{
	DBG_ASSERT((fs_entry_cache = KMEM_CACHE(struct fs_entry)) != 0);

	mutex_init(&fs_root_node.mux);
	fs_root_node.ops = &fs_root_node_ops;
	fs_root_node.fops = &fs_root_file_ops;

	fs_root_entry.node = &fs_root_node;
	fs_root_entry.parent = &fs_root_entry;
	fs_root_entry.refcount = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0xffffffff8010aaf6
movl $0x148, %edi            # imm = 0x148
movl $0x8, %esi
callq 0xffffffff80107380
movq %rax, 0x339584(%rip)    # 0xffffffff80444090
cmpq $0x0, %rax
jne 0xffffffff8010ab41
leaq 0x7660(%rip), %rdi      # 0xffffffff80112179
leaq 0x7cbf(%rip), %rsi      # 0xffffffff801127df
movl $0x2ee, %edx            # imm = 0x2EE
leaq 0x7651(%rip), %rcx      # 0xffffffff8011217d
leaq 0x7cb2(%rip), %r8       # 0xffffffff801127e5
movb $0x0, %al
callq 0xffffffff80101e60
callq 0xffffffff80111cd0
jmp 0xffffffff8010ab3f
jmp 0xffffffff8010ab43
leaq 0x33954e(%rip), %rdi    # 0xffffffff80444098
callq 0xffffffff8010aba0
leaq 0xd172(%rip), %rax      # 0xffffffff80117cc8
movq %rax, 0x33955b(%rip)    # 0xffffffff804440b8
leaq 0xd19c(%rip), %rax      # 0xffffffff80117d00
movq %rax, 0x339555(%rip)    # 0xffffffff804440c0
leaq 0x339526(%rip), %rax    # 0xffffffff80444098
movq %rax, 0x339587(%rip)    # 0xffffffff80444100
leaq 0x339558(%rip), %rax    # 0xffffffff804440d8
movq %rax, 0x339571(%rip)    # 0xffffffff804440f8
movl $0x1, 0x339687(%rip) # 0xffffffff80444218
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_walk_all
static int vfs_walk_all(struct vfs_walk_data *data)
{
	while (strcmp(data->next, "")) {
		const int rc = vfs_walk(data);

		if (rc)
			return rc;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq 0x8176(%rip), %rsi      # 0xffffffff80112e71
callq 0xffffffff80101980
cmpl $0x0, %eax
je 0xffffffff8010ad21
movq -0x10(%rbp), %rdi
callq 0xffffffff8010ad40
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xffffffff8010ad1f
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xffffffff8010ad28
jmp 0xffffffff8010acec
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_walk
static int vfs_walk(struct vfs_walk_data *data)
{
	if (!strcmp(data->next, ""))
		return -ENOENT;

	if (!strcmp(data->next, ".")) {
		data->tail = vfs_path_next_entry(data->next, data->tail);
		return 0;
	}

	if (!strcmp(data->next, "..")) {
		struct fs_entry *parent = vfs_entry_get(data->entry->parent);

		vfs_entry_put(data->entry);
		data->entry = parent;
		data->tail = vfs_path_next_entry(data->next, data->tail);
		return 0;
	}

	struct fs_entry *entry;
	int rc;

	mutex_lock(&data->entry->node->mux);
	entry = vfs_lookup(data->entry, data->next, false, &rc);
	mutex_unlock(&data->entry->node->mux);

	if (!entry)
		return rc;

	vfs_entry_put(data->entry);
	data->entry = entry;
	data->tail = vfs_path_next_entry(data->next, data->tail);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq 0x8116(%rip), %rsi      # 0xffffffff80112e71
callq 0xffffffff80101980
cmpl $0x0, %eax
jne 0xffffffff8010ad71
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xffffffff8010aec3
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq 0x7a9a(%rip), %rsi      # 0xffffffff8011281a
callq 0xffffffff80101980
cmpl $0x0, %eax
jne 0xffffffff8010adbc
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rsi
callq 0xffffffff8010aed0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x108(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xffffffff8010aec3
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq 0x7a4e(%rip), %rsi      # 0xffffffff80112819
callq 0xffffffff80101980
cmpl $0x0, %eax
jne 0xffffffff8010ae32
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
callq 0xffffffff80109620
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xffffffff80109680
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rsi
callq 0xffffffff8010aed0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x108(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xffffffff8010aec3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rdi
callq 0xffffffff8010dff0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
xorl %edx, %edx
leaq -0x24(%rbp), %rcx
callq 0xffffffff8010a290
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rdi
callq 0xffffffff8010e140
cmpq $0x0, -0x20(%rbp)
jne 0xffffffff8010ae7f
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xffffffff8010aec3
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xffffffff80109680
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rsi
callq 0xffffffff8010aed0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x108(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_path_next_entry
static const char *vfs_path_next_entry(char *next, const char *full)
{
	while (*full && *full != '/')
		*next++ = *full++;
	*next = '\0';
	return vfs_path_skip_sep(full);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0xffffffff8010af01
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xffffffff8010af0a
jmp 0xffffffff8010af2e
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0xffffffff8010aee0
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0xffffffff8010af50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_entry_create
static struct fs_entry *vfs_entry_create(const char *name)
{
	struct fs_entry *entry = kmem_cache_alloc(fs_entry_cache);

	if (!entry)
		return 0;

	memset(entry, 0, sizeof(*entry));
	spinlock_init(&entry->lock);
	strcpy(entry->name, name);
	entry->refcount = 1;
	return entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x3390dd(%rip), %rdi    # 0xffffffff80444090
callq 0xffffffff80106fd0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xffffffff8010afcd
movq $0x0, -0x8(%rbp)
jmp 0xffffffff8010b014
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x148, %edx            # imm = 0x148
callq 0xffffffff801017e0
movq -0x18(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0xffffffff8010b060
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0xffffffff80101a70
movq -0x18(%rbp), %rax
movl $0x1, 0x140(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: _vfs_lookup_mount
static struct fs_mount *__vfs_lookup_mount(const char *name)
{
	struct list_head *head = &fs_mounts;
	struct list_head *ptr = head->next;

	for (; ptr != head; ptr = ptr->next) {
		struct fs_mount *mnt = LIST_ENTRY(ptr, struct fs_mount, link);

		if (!strcmp(mnt->name, name))
			return mnt;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xcc9d(%rip), %rax      # 0xffffffff80117d30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xffffffff8010b0e3
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0xffffffff80101980
cmpl $0x0, %eax
jne 0xffffffff8010b0d4
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xffffffff8010b0eb
jmp 0xffffffff8010b0d6
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xffffffff8010b0a2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: _vfs_mount_create
static struct fs_mount *__vfs_mount_create(struct fs_type *fs, const char *name)
{
	struct fs_mount *mnt;

	if (fs->ops->alloc)
		mnt = fs->ops->alloc();
	else
		mnt = kmem_alloc(sizeof(*mnt));

	if (mnt) {
		memset(mnt, 0, sizeof(*mnt));
		strncpy(mnt->name, name, MAX_PATH_LEN - 1);
		mnt->fs = fs;
	}

	return mnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, (%rax)
je 0xffffffff8010b12e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
callq *(%rax)
movq %rax, -0x18(%rbp)
jmp 0xffffffff8010b13c
movl $0x120, %edi            # imm = 0x120
callq 0xffffffff80107510
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xffffffff8010b175
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x120, %edx            # imm = 0x120
callq 0xffffffff801017e0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
movl $0xff, %edx
callq 0xffffffff801019f0
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_root_lookup
static int vfs_root_lookup(struct fs_node *root, struct fs_entry *entry)
{
	struct list_head *head = &fs_mounts;
	struct list_head *ptr = head->next;

	(void) root;

	for (; ptr != head; ptr = ptr->next) {
		struct fs_mount *mount = LIST_ENTRY(ptr, struct fs_mount, link);
		const char *name = mount->name;

		if (!strcmp(name, entry->name)) {
			entry->node = vfs_node_get(mount->root);
			return 0;
		}
	}
	return -ENOENT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0xcb19(%rip), %rax      # 0xffffffff80117d30
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0xffffffff8010b28a
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
callq 0xffffffff80101980
cmpl $0x0, %eax
jne 0xffffffff8010b27b
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xffffffff8010b2a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xffffffff8010b291
jmp 0xffffffff8010b27d
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xffffffff8010b226
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/./vfs.h
// Function: vfs_node_get
static inline struct fs_node *vfs_node_get(struct fs_node *node)
{
	if (node) {
		const bool enabled = spin_lock_irqsave(&node->lock);
		++node->refcount;
		spin_unlock_irqrestore(&node->lock, enabled);
	}
	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xffffffff8010b2e7
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0xffffffff80109590
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xffffffff801095f0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/vfs.c
// Function: vfs_root_iterate
static int vfs_root_iterate(struct fs_file *root, struct dir_iter_ctx *ctx)
{
	struct list_head *head = &fs_mounts;
	struct list_head *ptr = head->next;

	(void) root;

	for (int i = 0; i != ctx->offset && ptr != head; ptr = ptr->next);

	while (ptr != head) {
		struct fs_mount *mount = LIST_ENTRY(ptr, struct fs_mount, link);
		const char *name = mount->name;

		if (ctx->emit(ctx, name, strlen(name))) {
			++ctx->offset;
			break;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xca19(%rip), %rax      # 0xffffffff80117d30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x8(%rdx), %ecx
movb %al, -0x39(%rbp)
je 0xffffffff8010b34c
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xffffffff8010b355
jmp 0xffffffff8010b364
jmp 0xffffffff8010b357
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xffffffff8010b32d
jmp 0xffffffff8010b366
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xffffffff8010b3d0
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
callq 0xffffffff801018d0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
movq -0x48(%rbp), %rax
callq *%rax
testb $0x1, %al
jne 0xffffffff8010b3bf
jmp 0xffffffff8010b3ce
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0xffffffff8010b3d0
jmp 0xffffffff8010b366
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/rbtree.c
// Function: rb_rightmost
struct rb_node *rb_rightmost(struct rb_node *node)
{
	if (!node)
		return 0;

	while (node->right)
		node = node->right;
	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xffffffff8010b3f9
movq $0x0, -0x8(%rbp)
jmp 0xffffffff8010b41c
jmp 0xffffffff8010b3fb
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xffffffff8010b414
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xffffffff8010b3fb
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/rbtree.c
// Function: rb_leftmost
struct rb_node *rb_leftmost(struct rb_node *node)
{
	if (!node)
		return 0;

	while (node->left)
		node = node->left;
	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xffffffff8010b449
movq $0x0, -0x8(%rbp)
jmp 0xffffffff8010b46a
jmp 0xffffffff8010b44b
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xffffffff8010b462
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xffffffff8010b44b
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/rbtree.c
// Function: rb_next
struct rb_node *rb_next(struct rb_node *node)
{
	if (!node)
		return 0;

	if (node->right)
		return rb_leftmost(node->right);

	struct rb_node *p = rb_parent(node);

	while (p && p->right == node) {
		node = p;
		p = rb_parent(p);
	}

	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xffffffff8010b48d
movq $0x0, -0x8(%rbp)
jmp 0xffffffff8010b4fe
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xffffffff8010b4ab
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xffffffff8010b430
movq %rax, -0x8(%rbp)
jmp 0xffffffff8010b4fe
movq -0x10(%rbp), %rdi
callq 0xffffffff8010b510
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0xffffffff8010b4d6
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xffffffff8010b4df
jmp 0xffffffff8010b4f6
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0xffffffff8010b510
movq %rax, -0x18(%rbp)
jmp 0xffffffff8010b4b8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)