LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/rbtree.c
// Function: rb_prev
struct rb_node *rb_prev(struct rb_node *node)
{
	if (!node)
		return 0;

	if (node->left)
		return rb_rightmost(node->left);

	struct rb_node *p = rb_parent(node);

	while (p && p->left == 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 0xffffffff8010b54d
movq $0x0, -0x8(%rbp)
jmp 0xffffffff8010b5bb
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xffffffff8010b569
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xffffffff8010b3e0
movq %rax, -0x8(%rbp)
jmp 0xffffffff8010b5bb
movq -0x10(%rbp), %rdi
callq 0xffffffff8010b510
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0xffffffff8010b593
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xffffffff8010b59c
jmp 0xffffffff8010b5b3
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0xffffffff8010b510
movq %rax, -0x18(%rbp)
jmp 0xffffffff8010b576
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/rbtree.c
// Function: rb_rotate_left
static void rb_rotate_left(struct rb_node *x, struct rb_tree *tree)
{
	struct rb_node *p = rb_parent(x);
	struct rb_node *r = x->right;

	x->right = r->left;
	if (x->right)
		rb_set_parent(x->right, x);
	r->left = x;
	rb_set_parent(r, p);

	if (p)
		if (p->left == x)
			p->left = r;
		else
			p->right = r;
	else
		tree->root = r;
	rb_set_parent(x, r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xffffffff8010b510
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xffffffff8010b834
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xffffffff8010bb70
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xffffffff8010bb70
cmpq $0x0, -0x18(%rbp)
je 0xffffffff8010b87b
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xffffffff8010b86d
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xffffffff8010b879
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xffffffff8010b886
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xffffffff8010bb70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/rbtree.c
// Function: rb_rotate_right
static void rb_rotate_right(struct rb_node *x, struct rb_tree *tree)
{
	struct rb_node *p = rb_parent(x);
	struct rb_node *l = x->left;

	x->left = l->right;
	if (x->left)
		rb_set_parent(x->left, x);
	l->right = x;
	rb_set_parent(l, p);

	if (p)
		if (p->left == x)
			p->left = l;
		else
			p->right = l;
	else
		tree->root = l;
	rb_set_parent(x, l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xffffffff8010b510
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xffffffff8010b8f1
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xffffffff8010bb70
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xffffffff8010bb70
cmpq $0x0, -0x18(%rbp)
je 0xffffffff8010b939
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xffffffff8010b92b
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xffffffff8010b937
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xffffffff8010b944
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xffffffff8010bb70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: setup_ramfs
void setup_ramfs(void)
{
	DBG_ASSERT((ramfs_node_cache = KMEM_CACHE(struct ramfs_node)) != 0);
	DBG_ASSERT((ramfs_entry_cache = KMEM_CACHE(struct ramfs_entry)) != 0);
	DBG_ASSERT((ramfs_page_cache = KMEM_CACHE(struct ramfs_page)) != 0);
	DBG_ASSERT(register_filesystem(&ramfs_type) == 0);

#ifdef CONFIG_RAMFS_TEST
	void ramfs_test(void);

	ramfs_test();
#endif /* CONFIG_RAMFS_TEST */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0xffffffff8010bec6
movl $0x50, %edi
movl $0x8, %esi
callq 0xffffffff80107380
movq %rax, 0x338344(%rip)    # 0xffffffff80444220
cmpq $0x0, %rax
jne 0xffffffff8010bf11
leaq 0x6290(%rip), %rdi      # 0xffffffff80112179
leaq 0x6fa9(%rip), %rsi      # 0xffffffff80112e99
movl $0x1e5, %edx            # imm = 0x1E5
leaq 0x6281(%rip), %rcx      # 0xffffffff8011217d
leaq 0x6919(%rip), %r8       # 0xffffffff8011281c
movb $0x0, %al
callq 0xffffffff80101e60
callq 0xffffffff80111cd0
jmp 0xffffffff8010bf0f
jmp 0xffffffff8010bf13
jmp 0xffffffff8010bf15
movl $0x120, %edi            # imm = 0x120
movl $0x8, %esi
callq 0xffffffff80107380
movq %rax, 0x3382fd(%rip)    # 0xffffffff80444228
cmpq $0x0, %rax
jne 0xffffffff8010bf60
leaq 0x6241(%rip), %rdi      # 0xffffffff80112179
leaq 0x6f5a(%rip), %rsi      # 0xffffffff80112e99
movl $0x1e6, %edx            # imm = 0x1E6
leaq 0x6232(%rip), %rcx      # 0xffffffff8011217d
leaq 0x6902(%rip), %r8       # 0xffffffff80112854
movb $0x0, %al
callq 0xffffffff80101e60
callq 0xffffffff80111cd0
jmp 0xffffffff8010bf5e
jmp 0xffffffff8010bf62
jmp 0xffffffff8010bf64
movl $0x28, %edi
movl $0x8, %esi
callq 0xffffffff80107380
movq %rax, 0x3382b6(%rip)    # 0xffffffff80444230
cmpq $0x0, %rax
jne 0xffffffff8010bfaf
leaq 0x61f2(%rip), %rdi      # 0xffffffff80112179
leaq 0x6f0b(%rip), %rsi      # 0xffffffff80112e99
movl $0x1e7, %edx            # imm = 0x1E7
leaq 0x61e3(%rip), %rcx      # 0xffffffff8011217d
leaq 0x68ed(%rip), %r8       # 0xffffffff8011288e
movb $0x0, %al
callq 0xffffffff80101e60
callq 0xffffffff80111cd0
jmp 0xffffffff8010bfad
jmp 0xffffffff8010bfb1
jmp 0xffffffff8010bfb3
leaq 0xbd86(%rip), %rdi      # 0xffffffff80117d40
callq 0xffffffff8010a7a0
cmpl $0x0, %eax
je 0xffffffff8010bff3
leaq 0x61ae(%rip), %rdi      # 0xffffffff80112179
leaq 0x6ec7(%rip), %rsi      # 0xffffffff80112e99
movl $0x1e8, %edx            # imm = 0x1E8
leaq 0x619f(%rip), %rcx      # 0xffffffff8011217d
leaq 0x68e1(%rip), %r8       # 0xffffffff801128c6
movb $0x0, %al
callq 0xffffffff80101e60
callq 0xffffffff80111cd0
jmp 0xffffffff8010bff1
jmp 0xffffffff8010bff5
callq 0xffffffff8010d2b0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: ramfs_mount
static int ramfs_mount(struct fs_mount *mnt, const void *data, size_t size)
{
	(void) data;
	(void) size;

	struct ramfs_node *root = ramfs_node_create(&ramfs_dir_node_ops,
		&ramfs_dir_ops);

	if (!root)
		return -ENOMEM;

	mnt->root = VFS_NODE(root);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0xbd6d(%rip), %rdi      # 0xffffffff80117d88
leaq 0xbd9e(%rip), %rsi      # 0xffffffff80117dc0
callq 0xffffffff8010c080
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xffffffff8010c03b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xffffffff8010c056
movq -0x28(%rbp), %rdi
callq 0xffffffff8010c120
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: ramfs_node_create
static struct ramfs_node *ramfs_node_create(struct fs_node_ops *ops,
			struct fs_file_ops *fops)
{
	struct ramfs_node *node = kmem_cache_alloc(ramfs_node_cache);

	if (node) {
		memset(node, 0, sizeof(*node));
		vfs_node_init(VFS_NODE(node));
		vfs_node_get(VFS_NODE(node));
		VFS_NODE(node)->ops = ops;
		VFS_NODE(node)->fops = fops;
	}
	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x338189(%rip), %rdi    # 0xffffffff80444220
callq 0xffffffff80106fd0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xffffffff8010c10b
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0xffffffff801017e0
movq -0x18(%rbp), %rdi
callq 0xffffffff8010c120
movq %rax, %rdi
callq 0xffffffff8010c130
movq -0x18(%rbp), %rdi
callq 0xffffffff8010c120
movq %rax, %rdi
callq 0xffffffff8010c170
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xffffffff8010c120
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xffffffff8010c120
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: ramfs_link
static int ramfs_link(struct fs_entry *src, struct fs_node *dir,
			struct fs_entry *dst)
{
	struct ramfs_node *parent = RAMFS_NODE(dir);
	struct ramfs_dir_iterator iter;

	if (src->node->ops != &ramfs_file_node_ops)
		return -ENOTSUP;

	/* Just a sanity check */
	if (dir->ops != &ramfs_dir_node_ops)
		return -ENOTSUP;

	if (ramfs_entry_lookup(parent, dst->name, &iter))
		return -EEXIST;

	struct ramfs_node *node = RAMFS_NODE(vfs_node_get(src->node));
	struct ramfs_entry *entry = ramfs_entry_create(dst->name, node);

	if (!entry) {
		vfs_node_put(VFS_NODE(node));
		return -ENOMEM;
	}

	ramfs_entry_link(parent, entry, &iter);
	dst->node = vfs_node_get(VFS_NODE(node));
	return 0;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xffffffff8010c7b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
leaq 0xba00(%rip), %rcx      # 0xffffffff80117df0
cmpq %rcx, 0x20(%rax)
je 0xffffffff8010c402
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xffffffff8010c4c9
movq -0x18(%rbp), %rax
leaq 0xb97b(%rip), %rcx      # 0xffffffff80117d88
cmpq %rcx, 0x20(%rax)
je 0xffffffff8010c41f
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xffffffff8010c4c9
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x30, %rsi
leaq -0x40(%rbp), %rdx
callq 0xffffffff8010c7c0
testb $0x1, %al
jne 0xffffffff8010c43a
jmp 0xffffffff8010c446
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xffffffff8010c4c9
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xffffffff8010c170
movq %rax, %rdi
callq 0xffffffff8010c7b0
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movq -0x48(%rbp), %rsi
callq 0xffffffff8010c890
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0xffffffff8010c495
movq -0x48(%rbp), %rdi
callq 0xffffffff8010c120
movq %rax, %rdi
callq 0xffffffff8010c8f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xffffffff8010c4c9
movq -0x28(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0xffffffff8010c960
movq -0x48(%rbp), %rdi
callq 0xffffffff8010c120
movq %rax, %rdi
callq 0xffffffff8010c170
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: ramfs_unlink
static int ramfs_unlink(struct fs_node *dir, struct fs_entry *entry)
{
	struct ramfs_node *parent = RAMFS_NODE(dir);

	if (dir->ops != &ramfs_dir_node_ops)
		return -ENOTSUP;

	if (!entry->node)
		return -EINVAL;

	if (entry->node->ops != &ramfs_file_node_ops)
		return -ENOTSUP;

	return ramfs_entry_unlink(parent, entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xffffffff8010c7b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
leaq 0xb880(%rip), %rcx      # 0xffffffff80117d88
cmpq %rcx, 0x20(%rax)
je 0xffffffff8010c517
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xffffffff8010c559
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xffffffff8010c52b
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0xffffffff8010c559
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
leaq 0xb8b6(%rip), %rcx      # 0xffffffff80117df0
cmpq %rcx, 0x20(%rax)
je 0xffffffff8010c549
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xffffffff8010c559
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xffffffff8010d010
movl %eax, -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/ramfs.c
// Function: ramfs_rmdir
static int ramfs_rmdir(struct fs_node *dir, struct fs_entry *entry)
{
	struct ramfs_node *parent = RAMFS_NODE(dir);

	if (dir->ops != &ramfs_dir_node_ops)
		return -ENOTSUP;

	return ramfs_entry_unlink(parent, entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xffffffff8010c7b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
leaq 0xb7b0(%rip), %rcx      # 0xffffffff80117d88
cmpq %rcx, 0x20(%rax)
je 0xffffffff8010c5e7
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xffffffff8010c5f7
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xffffffff8010d010
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: ramfs_lookup
static int ramfs_lookup(struct fs_node *dir, struct fs_entry *entry)
{
	struct ramfs_node *parent = RAMFS_NODE(dir);
	struct ramfs_dir_iterator iter;

	if (dir->ops != &ramfs_dir_node_ops)
		return -ENOTSUP;

	if (!ramfs_entry_lookup(parent, entry->name, &iter))
		return -ENOENT;

	entry->node = vfs_node_get(VFS_NODE(iter.entry->node));
	return 0;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xffffffff8010c7b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
leaq 0xb760(%rip), %rcx      # 0xffffffff80117d88
cmpq %rcx, 0x20(%rax)
je 0xffffffff8010c637
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xffffffff8010c680
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
leaq -0x38(%rbp), %rdx
callq 0xffffffff8010c7c0
testb $0x1, %al
jne 0xffffffff8010c659
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xffffffff8010c680
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xffffffff8010c120
movq %rax, %rdi
callq 0xffffffff8010c170
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: ramfs_create_ops
static int ramfs_create_ops(struct fs_node *dir, struct fs_entry *file,
			struct fs_node_ops *ops, struct fs_file_ops *fops)
{
	struct ramfs_node *parent = RAMFS_NODE(dir);
	struct ramfs_dir_iterator iter;

	if (ramfs_entry_lookup(parent, file->name, &iter))
		return -EEXIST;

	struct ramfs_node *node = ramfs_node_create(ops, fops);

	if (!node)
		return -ENOMEM;

	struct ramfs_entry *entry = ramfs_entry_create(file->name, node);

	if (!entry) {
		vfs_node_put(VFS_NODE(node));
		return -ENOMEM;
	}

	ramfs_entry_link(parent, entry, &iter);
	file->node = vfs_node_get(VFS_NODE(node));
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xffffffff8010c7b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
leaq -0x48(%rbp), %rdx
callq 0xffffffff8010c7c0
testb $0x1, %al
jne 0xffffffff8010c710
jmp 0xffffffff8010c71c
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xffffffff8010c7a7
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xffffffff8010c080
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0xffffffff8010c73d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xffffffff8010c7a7
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movq -0x50(%rbp), %rsi
callq 0xffffffff8010c890
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0xffffffff8010c773
movq -0x50(%rbp), %rdi
callq 0xffffffff8010c120
movq %rax, %rdi
callq 0xffffffff8010c8f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xffffffff8010c7a7
movq -0x30(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0xffffffff8010c960
movq -0x50(%rbp), %rdi
callq 0xffffffff8010c120
movq %rax, %rdi
callq 0xffffffff8010c170
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: ramfs_entry_lookup
static bool ramfs_entry_lookup(struct ramfs_node *dir, const char *name,
			struct ramfs_dir_iterator *iter)
{
	struct rb_node **plink = &dir->children.root;
	struct rb_node *parent = 0;
	struct ramfs_entry *entry;

	iter->entry = 0;

	while (*plink) {
		entry = TREE_ENTRY(*plink, struct ramfs_entry, link);

		const int cmp = strcmp(entry->name, name);

		if (!cmp) {
			iter->entry = entry;
			break;
		}

		parent = *plink;
		if (cmp < 0)
			plink = &parent->right;
		else
			plink = &parent->left;
	}

	iter->parent = parent;
	iter->plink = plink;

	return iter->entry != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xffffffff8010c858
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0xffffffff80101980
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0xffffffff8010c82f
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xffffffff8010c858
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0xffffffff8010c84e
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0xffffffff8010c856
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xffffffff8010c7f3
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: ramfs_entry_create
static struct ramfs_entry *ramfs_entry_create(const char *name,
			struct ramfs_node *node)
{
	struct ramfs_entry *entry = kmem_cache_alloc(ramfs_entry_cache);

	if (entry) {
		memset(entry, 0, sizeof(*entry));
		strcpy(entry->name, name);
		entry->node = node;
	}
	return entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x337981(%rip), %rdi    # 0xffffffff80444228
callq 0xffffffff80106fd0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xffffffff8010c8e4
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x120, %edx            # imm = 0x120
callq 0xffffffff801017e0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x8(%rbp), %rsi
callq 0xffffffff80101a70
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: ramfs_entry_link
static void ramfs_entry_link(struct ramfs_node *dir, struct ramfs_entry *entry,
			struct ramfs_dir_iterator *iter)
{
	const bool enabled = spin_lock_irqsave(&VFS_NODE(dir)->lock);

	++VFS_NODE(dir)->refcount;
	++VFS_NODE(dir)->size;
	spin_unlock_irqrestore(&VFS_NODE(dir)->lock, enabled);

	rb_link(&entry->link, iter->parent, iter->plink);
	rb_insert(&entry->link, &dir->children);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xffffffff8010c120
movq %rax, %rdi
addq $0x30, %rdi
callq 0xffffffff8010c250
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
callq 0xffffffff8010c120
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rdi
callq 0xffffffff8010c120
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rdi
callq 0xffffffff8010c120
movq %rax, %rdi
addq $0x30, %rdi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xffffffff8010c270
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0xffffffff8010ca00
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x40, %rsi
callq 0xffffffff8010b5d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: _ramfs_release_file_node
static void __ramfs_release_file_node(struct rb_node *node)
{
	while (node) {
		struct ramfs_page *page = TREE_ENTRY(node, struct ramfs_page,
					link);

		__ramfs_release_file_node(node->right);
		node = node->left;
		ramfs_free_page(page);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xffffffff8010cabe
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xffffffff8010ca80
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0xffffffff8010cad0
jmp 0xffffffff8010ca8c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: ramfs_read
static int ramfs_read(struct fs_file *file, char *data, size_t size)
{
	struct fs_node *fs_node = file->node;
	struct ramfs_node *node = RAMFS_NODE(fs_node);

	mutex_lock(&fs_node->mux);
	if (file->offset >= file->node->size) {
		mutex_unlock(&fs_node->mux);
		return 0;
	}

	const size_t rem = file->node->size - file->offset;
	const size_t idx = file->offset >> PAGE_BITS;
	const size_t off = file->offset & PAGE_MASK;
	const size_t sz = MINU(MINU(PAGE_SIZE - off, size), rem);

	struct ramfs_page_iter iter;

	if (ramfs_lookup_page(node, &iter, idx)) {
		struct page *page = iter.page->page;
		char *vaddr = page_addr(page);

		memcpy(data, vaddr + off, sz);
	} else {
		memset(data, 0, sz);
	}

	file->offset += sz;
	mutex_unlock(&fs_node->mux);

	return (int)sz;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xffffffff8010c7b0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xffffffff8010dff0
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x3c(%rcx), %eax
jl 0xffffffff8010cb72
movq -0x28(%rbp), %rdi
callq 0xffffffff8010e140
movl $0x0, -0x4(%rbp)
jmp 0xffffffff8010cc45
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x3c(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x18(%rcx), %eax
cltq
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
sarl $0xc, %eax
cltq
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movslq 0x18(%rax), %rax
andq $0xfff, %rax            # imm = 0xFFF
movq %rax, -0x48(%rbp)
movl $0x1000, %edi           # imm = 0x1000
subq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xffffffff8010cdc0
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0xffffffff8010cdc0
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq -0x68(%rbp), %rsi
callq 0xffffffff8010cdf0
cmpl $0x0, %eax
je 0xffffffff8010cc14
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0xffffffff8010ced0
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
movq -0x78(%rbp), %rsi
addq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0xffffffff801016a0
jmp 0xffffffff8010cc23
movq -0x18(%rbp), %rdi
movq -0x50(%rbp), %rdx
xorl %esi, %esi
callq 0xffffffff801017e0
movq -0x50(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq 0x18(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x18(%rax)
movq -0x28(%rbp), %rdi
callq 0xffffffff8010e140
movq -0x50(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: ramfs_write
static int ramfs_write(struct fs_file *file, const char *data, size_t size)
{
	struct fs_node *fs_node = file->node;
	struct ramfs_node *node = RAMFS_NODE(fs_node);

	mutex_lock(&fs_node->mux);

	const size_t idx = file->offset >> PAGE_BITS;
	const size_t off = file->offset & PAGE_MASK;
	const size_t sz = MINU(PAGE_SIZE - off, size);

	struct ramfs_page_iter iter;
	struct ramfs_page *rpage;

	if (ramfs_lookup_page(node, &iter, idx)) {
		rpage = iter.page;
	} else {
		rpage = ramfs_alloc_page(idx);
		if (!rpage) {
			mutex_unlock(&fs_node->mux);
			return -ENOMEM;
		}

		rb_link(&rpage->link, iter.parent, iter.plink);
		rb_insert(&rpage->link, &node->pages);
	}

	struct page *page = rpage->page;
	char *vaddr = page_addr(page);

	memcpy(vaddr + off, data, sz);
	file->offset += sz;
	file->node->size = MAX(file->offset, file->node->size);
	mutex_unlock(&fs_node->mux);

	return (int)sz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xffffffff8010c7b0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xffffffff8010dff0
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
sarl $0xc, %eax
cltq
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq 0x18(%rax), %rax
andq $0xfff, %rax            # imm = 0xFFF
movq %rax, -0x40(%rbp)
movl $0x1000, %edi           # imm = 0x1000
subq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xffffffff8010cdc0
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq -0x60(%rbp), %rsi
callq 0xffffffff8010cdf0
cmpl $0x0, %eax
je 0xffffffff8010ccf1
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0xffffffff8010cd3c
movq -0x38(%rbp), %rdi
callq 0xffffffff8010cf40
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0xffffffff8010cd1a
movq -0x28(%rbp), %rdi
callq 0xffffffff8010e140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xffffffff8010cdb2
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0xffffffff8010ca00
movq -0x68(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x48, %rsi
callq 0xffffffff8010b5d0
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0xffffffff8010ced0
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
addq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0xffffffff801016a0
movq -0x48(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq 0x18(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movslq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq 0x3c(%rax), %rsi
callq 0xffffffff8010cfe0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl %ecx, 0x3c(%rax)
movq -0x28(%rbp), %rdi
callq 0xffffffff8010e140
movq -0x48(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: ramfs_lookup_page
static int ramfs_lookup_page(struct ramfs_node *node,
			struct ramfs_page_iter *iter, size_t index)
{
	struct rb_node **plink = &node->pages.root;
	struct rb_node *parent = 0;

	while (*plink) {
		struct ramfs_page *page = TREE_ENTRY(*plink, struct ramfs_page,
					link);

		if (page->index == index) {
			iter->plink = plink;
			iter->parent = parent;
			iter->page = page;
			return 1;
		}

		parent = *plink;
		if (page->index < index)
			plink = &parent->right;
		else
			plink = &parent->left;
	}

	iter->plink = plink;
	iter->parent = parent;
	iter->page = 0;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0xffffffff8010ce94
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0xffffffff8010ce63
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xffffffff8010cebe
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x20(%rbp), %rax
jae 0xffffffff8010ce8a
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0xffffffff8010ce92
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xffffffff8010ce14
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: ramfs_alloc_page
static struct ramfs_page *ramfs_alloc_page(size_t index)
{
	struct ramfs_page *rpage = kmem_cache_alloc(ramfs_page_cache);

	if (!rpage)
		return 0;

	rpage->page = alloc_pages(0);

	if (!rpage->page) {
		kmem_cache_free(ramfs_page_cache, rpage);
		return 0;
	}

	memset(page_addr(rpage->page), 0, PAGE_SIZE);
	rpage->index = index;
	return rpage;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x3372dd(%rip), %rdi    # 0xffffffff80444230
callq 0xffffffff80106fd0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xffffffff8010cf6d
movq $0x0, -0x8(%rbp)
jmp 0xffffffff8010cfd4
xorl %edi, %edi
callq 0xffffffff801043b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xffffffff8010cfa4
movq 0x33729f(%rip), %rdi    # 0xffffffff80444230
movq -0x18(%rbp), %rsi
callq 0xffffffff80107260
movq $0x0, -0x8(%rbp)
jmp 0xffffffff8010cfd4
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xffffffff8010ced0
movq %rax, %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0xffffffff801017e0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%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/ramfs.c
// Function: ramfs_entry_unlink
static int ramfs_entry_unlink(struct ramfs_node *dir, struct fs_entry *entry)
{
	struct ramfs_dir_iterator iter;

	if (!ramfs_entry_lookup(dir, entry->name, &iter))
		return -ENOENT;

	rb_erase(&iter.entry->link, &dir->children);

	const bool enabled = spin_lock_irqsave(&VFS_NODE(dir)->lock);
	--VFS_NODE(dir)->size;
	spin_unlock_irqrestore(&VFS_NODE(dir)->lock, enabled);

	ramfs_entry_destroy(iter.entry);
	vfs_entry_detach(entry);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
leaq -0x30(%rbp), %rdx
callq 0xffffffff8010c7c0
testb $0x1, %al
jne 0xffffffff8010d042
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xffffffff8010d0b5
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0xffffffff8010b960
movq -0x10(%rbp), %rdi
callq 0xffffffff8010c120
movq %rax, %rdi
addq $0x30, %rdi
callq 0xffffffff8010c250
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rdi
callq 0xffffffff8010c120
movl 0x3c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x3c(%rax)
movq -0x10(%rbp), %rdi
callq 0xffffffff8010c120
movq %rax, %rdi
addq $0x30, %rdi
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xffffffff8010c270
movq -0x30(%rbp), %rdi
callq 0xffffffff8010d0c0
movq -0x18(%rbp), %rdi
callq 0xffffffff80109530
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: ramfs_dir_release
static void ramfs_dir_release(struct rb_node *node)
{
	while (node) {
		struct ramfs_entry *entry = TREE_ENTRY(node, struct ramfs_entry,
					link);

		ramfs_entry_destroy(entry);
		ramfs_dir_release(node->right);
		node = node->left;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xffffffff8010d13e
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xffffffff8010d0c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xffffffff8010d100
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xffffffff8010d10c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs.c
// Function: ramfs_iterate
static int ramfs_iterate(struct fs_file *dir, struct dir_iter_ctx *ctx)
{
	struct ramfs_node *node = RAMFS_NODE(dir->node);
	struct rb_node *ptr = rb_leftmost(node->children.root);

	int offset = ctx->offset;

	while (ptr && offset--)
		ptr = rb_next(ptr);

	while (ptr) {
		struct ramfs_entry *entry = TREE_ENTRY(ptr,
			struct ramfs_entry, link);

		ptr = rb_next(ptr);
		if (!ctx->emit(ctx, entry->name, strlen(entry->name)))
			break;
		++ctx->offset;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xffffffff8010c7b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0xffffffff8010b430
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x31(%rbp)
je 0xffffffff8010d1ac
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xffffffff8010d1b5
jmp 0xffffffff8010d1c4
movq -0x20(%rbp), %rdi
callq 0xffffffff8010b470
movq %rax, -0x20(%rbp)
jmp 0xffffffff8010d18c
jmp 0xffffffff8010d1c6
cmpq $0x0, -0x20(%rbp)
je 0xffffffff8010d234
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0xffffffff8010b470
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0xffffffff801018d0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
movq -0x40(%rbp), %rax
callq *%rax
testb $0x1, %al
jne 0xffffffff8010d225
jmp 0xffffffff8010d234
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0xffffffff8010d1c6
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs_smoke_test.c
// Function: ramfs_test
void ramfs_test(void)
{
	int rc = vfs_mount("ramfs", RAMFS_ROOT, 0, 0);

	if (!rc) {
		DBG_INFO("successfully mounted");
		ramfs_do_test();
		rc = vfs_umount(RAMFS_ROOT);
		if (rc)
			DBG_ERR("vfs_umount failed with %d", rc);
		else
			DBG_INFO("successfully unmounted");
	} else {
		DBG_ERR("vfs_mount failed with %d", rc);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x5bd0(%rip), %rdi      # 0xffffffff80112e8f
leaq 0x582b(%rip), %rsi      # 0xffffffff80112af1
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xffffffff8010a8f0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xffffffff8010d364
leaq 0x4e5e(%rip), %rdi      # 0xffffffff80112144
leaq 0x56c5(%rip), %rsi      # 0xffffffff801129b2
movl $0xd9, %edx
leaq 0x56cc(%rip), %rcx      # 0xffffffff801129c5
movb $0x0, %al
callq 0xffffffff80101e60
callq 0xffffffff8010d390
leaq 0x57e5(%rip), %rdi      # 0xffffffff80112af1
callq 0xffffffff8010aa30
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xffffffff8010d341
movl -0x4(%rbp), %r8d
leaq 0x4e54(%rip), %rdi      # 0xffffffff80112179
leaq 0x5686(%rip), %rsi      # 0xffffffff801129b2
movl $0xdd, %edx
leaq 0x56a2(%rip), %rcx      # 0xffffffff801129da
movb $0x0, %al
callq 0xffffffff80101e60
jmp 0xffffffff8010d362
leaq 0x4dfc(%rip), %rdi      # 0xffffffff80112144
leaq 0x5663(%rip), %rsi      # 0xffffffff801129b2
movl $0xdf, %edx
leaq 0x5699(%rip), %rcx      # 0xffffffff801129f4
movb $0x0, %al
callq 0xffffffff80101e60
jmp 0xffffffff8010d389
movl -0x4(%rbp), %r8d
leaq 0x4e0a(%rip), %rdi      # 0xffffffff80112179
leaq 0x563c(%rip), %rsi      # 0xffffffff801129b2
movl $0xe1, %edx
leaq 0x5689(%rip), %rcx      # 0xffffffff80112a0b
movb $0x0, %al
callq 0xffffffff80101e60
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs_smoke_test.c
// Function: ramfs_do_test
static void ramfs_do_test(void)
{
	test_create();
	test_open();
	test_root();
	test_read_write();
	test_read_beyond_the_end();
	test_unlink();
	test_root();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0xffffffff8010d3c0
callq 0xffffffff8010d4c0
callq 0xffffffff8010d5c0
callq 0xffffffff8010d6c0
callq 0xffffffff8010dac0
callq 0xffffffff8010dcd0
callq 0xffffffff8010d5c0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs_smoke_test.c
// Function: test_create
static void test_create(void)
{
	struct fs_file file;
	const char *file_path = RAMFS_FILE_PATH;
	int rc = vfs_create(file_path, &file);

	if (!rc) {
		DBG_INFO("vfs_create(%s) succeeded", file_path);
		rc = vfs_release(&file);
		if (!rc)
			DBG_INFO("vfs_release succeeded");
		else
			DBG_ERR("vfs_release failed with error: %s",
				errstr(rc));
	} else {
		DBG_ERR("vfs_create(%s) failed with error: %s",
			file_path, errstr(rc));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x5655(%rip), %rax      # 0xffffffff80112a24
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xffffffff80109870
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0xffffffff8010d475
movq -0x28(%rbp), %r8
leaq 0x4d4c(%rip), %rdi      # 0xffffffff80112144
leaq 0x55b3(%rip), %rsi      # 0xffffffff801129b2
movl $0x22, %edx
leaq 0x5635(%rip), %rcx      # 0xffffffff80112a40
movb $0x0, %al
callq 0xffffffff80101e60
leaq -0x20(%rbp), %rdi
callq 0xffffffff80109ae0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0xffffffff8010d447
leaq 0x4d19(%rip), %rdi      # 0xffffffff80112144
leaq 0x5580(%rip), %rsi      # 0xffffffff801129b2
movl $0x25, %edx
leaq 0x561b(%rip), %rcx      # 0xffffffff80112a59
movb $0x0, %al
callq 0xffffffff80101e60
jmp 0xffffffff8010d473
movl -0x2c(%rbp), %edi
callq 0xffffffff8010d240
movq %rax, %r8
leaq 0x4d20(%rip), %rdi      # 0xffffffff80112179
leaq 0x5552(%rip), %rsi      # 0xffffffff801129b2
movl $0x28, %edx
leaq 0x5603(%rip), %rcx      # 0xffffffff80112a6f
movb $0x0, %al
callq 0xffffffff80101e60
jmp 0xffffffff8010d4ad
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %edi
callq 0xffffffff8010d240
movq -0x38(%rbp), %r8
movq %rax, %r9
leaq 0x4ce6(%rip), %rdi      # 0xffffffff80112179
leaq 0x5518(%rip), %rsi      # 0xffffffff801129b2
movl $0x2b, %edx
leaq 0x55eb(%rip), %rcx      # 0xffffffff80112a91
movb $0x0, %al
callq 0xffffffff80101e60
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs_smoke_test.c
// Function: test_open
static void test_open(void)
{
	struct fs_file file;
	const char *file_path = RAMFS_FILE_PATH;
	int rc = vfs_open(file_path, &file);

	if (!rc) {
		DBG_INFO("vfs_open(%s) succeeded", file_path);
		rc = vfs_release(&file);
		if (!rc)
			DBG_INFO("vfs_release succeeded");
		else
			DBG_ERR("vfs_release failed with error: %s",
				errstr(rc));
	} else {
		DBG_ERR("vfs_open(%s) failed with error: %s",
			file_path, errstr(rc));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x5555(%rip), %rax      # 0xffffffff80112a24
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xffffffff80109ab0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0xffffffff8010d575
movq -0x28(%rbp), %r8
leaq 0x4c4c(%rip), %rdi      # 0xffffffff80112144
leaq 0x54b3(%rip), %rsi      # 0xffffffff801129b2
movl $0x36, %edx
leaq 0x55ab(%rip), %rcx      # 0xffffffff80112ab6
movb $0x0, %al
callq 0xffffffff80101e60
leaq -0x20(%rbp), %rdi
callq 0xffffffff80109ae0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0xffffffff8010d547
leaq 0x4c19(%rip), %rdi      # 0xffffffff80112144
leaq 0x5480(%rip), %rsi      # 0xffffffff801129b2
movl $0x39, %edx
leaq 0x551b(%rip), %rcx      # 0xffffffff80112a59
movb $0x0, %al
callq 0xffffffff80101e60
jmp 0xffffffff8010d573
movl -0x2c(%rbp), %edi
callq 0xffffffff8010d240
movq %rax, %r8
leaq 0x4c20(%rip), %rdi      # 0xffffffff80112179
leaq 0x5452(%rip), %rsi      # 0xffffffff801129b2
movl $0x3c, %edx
leaq 0x5503(%rip), %rcx      # 0xffffffff80112a6f
movb $0x0, %al
callq 0xffffffff80101e60
jmp 0xffffffff8010d5ad
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %edi
callq 0xffffffff8010d240
movq -0x38(%rbp), %r8
movq %rax, %r9
leaq 0x4be6(%rip), %rdi      # 0xffffffff80112179
leaq 0x5418(%rip), %rsi      # 0xffffffff801129b2
movl $0x3f, %edx
leaq 0x5527(%rip), %rcx      # 0xffffffff80112acd
movb $0x0, %al
callq 0xffffffff80101e60
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs_smoke_test.c
// Function: test_root
static void test_root(void)
{
	struct fs_file root_dir;
	const char *root_path = RAMFS_ROOT_PATH;
	int rc = vfs_open(root_path, &root_dir);

	if (!rc) {
		DBG_INFO("vfs_open(%s) succeeded", root_path);
		test_readdir(&root_dir);
		rc = vfs_release(&root_dir);
		if (rc)
			DBG_ERR("vfs_release failed with error: %s",
				errstr(rc));
		else
			DBG_INFO("vfs_release succeeded");
	} else {
		DBG_ERR("vfs_open(%s) failed with error: %s",
			root_path, errstr(rc));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x5521(%rip), %rax      # 0xffffffff80112af0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xffffffff80109ab0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0xffffffff8010d67e
movq -0x28(%rbp), %r8
leaq 0x4b4c(%rip), %rdi      # 0xffffffff80112144
leaq 0x53b3(%rip), %rsi      # 0xffffffff801129b2
movl $0x56, %edx
leaq 0x54ab(%rip), %rcx      # 0xffffffff80112ab6
movb $0x0, %al
callq 0xffffffff80101e60
leaq -0x20(%rbp), %rdi
callq 0xffffffff8010dd60
leaq -0x20(%rbp), %rdi
callq 0xffffffff80109ae0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xffffffff8010d65b
movl -0x2c(%rbp), %edi
callq 0xffffffff8010d240
movq %rax, %r8
leaq 0x4b3a(%rip), %rdi      # 0xffffffff80112179
leaq 0x536c(%rip), %rsi      # 0xffffffff801129b2
movl $0x5b, %edx
leaq 0x541d(%rip), %rcx      # 0xffffffff80112a6f
movb $0x0, %al
callq 0xffffffff80101e60
jmp 0xffffffff8010d67c
leaq 0x4ae2(%rip), %rdi      # 0xffffffff80112144
leaq 0x5349(%rip), %rsi      # 0xffffffff801129b2
movl $0x5d, %edx
leaq 0x53e4(%rip), %rcx      # 0xffffffff80112a59
movb $0x0, %al
callq 0xffffffff80101e60
jmp 0xffffffff8010d6b6
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %edi
callq 0xffffffff8010d240
movq -0x38(%rbp), %r8
movq %rax, %r9
leaq 0x4add(%rip), %rdi      # 0xffffffff80112179
leaq 0x530f(%rip), %rsi      # 0xffffffff801129b2
movl $0x60, %edx
leaq 0x541e(%rip), %rcx      # 0xffffffff80112acd
movb $0x0, %al
callq 0xffffffff80101e60
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs_smoke_test.c
// Function: test_unlink
static void test_unlink(void)
{
	const char *file_path = RAMFS_FILE_PATH;
	int rc = vfs_unlink(file_path);

	if (!rc)
		DBG_INFO("vfs_unlink(%s) succeeded", file_path);
	else
		DBG_ERR("vfs_unlink(%s) failed with error: %s",
			file_path, errstr(rc));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x4d45(%rip), %rax      # 0xffffffff80112a24
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xffffffff8010a490
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xffffffff8010dd1c
movq -0x8(%rbp), %r8
leaq 0x4444(%rip), %rdi      # 0xffffffff80112144
leaq 0x4cab(%rip), %rsi      # 0xffffffff801129b2
movl $0x49, %edx
leaq 0x4fb9(%rip), %rcx      # 0xffffffff80112ccc
movb $0x0, %al
callq 0xffffffff80101e60
jmp 0xffffffff8010dd54
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0xffffffff8010d240
movq -0x18(%rbp), %r8
movq %rax, %r9
leaq 0x443f(%rip), %rdi      # 0xffffffff80112179
leaq 0x4c71(%rip), %rsi      # 0xffffffff801129b2
movl $0x4c, %edx
leaq 0x4f98(%rip), %rcx      # 0xffffffff80112ce5
movb $0x0, %al
callq 0xffffffff80101e60
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/ramfs_smoke_test.c
// Function: test_readdir
static void test_readdir(struct fs_file *dir)
{
	struct dirent entries[RAMFS_DIRN];
	int rc = vfs_readdir(dir, entries, RAMFS_DIRN);

	if (rc >= 0) {
		DBG_INFO("vfs_readdir returned %d entries", rc);
		for (int i = 0; i != rc; ++i)
			DBG_INFO("entry: %s", entries[i].name);
	} else {
		DBG_ERR("vfs_readdir failed with error: %s", errstr(rc));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa20, %rsp            # imm = 0xA20
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xa10(%rbp), %rsi
movl $0xa, %edx
callq 0xffffffff80109d70
movl %eax, -0xa14(%rbp)
cmpl $0x0, -0xa14(%rbp)
jl 0xffffffff8010de20
movl -0xa14(%rbp), %r8d
leaq 0x439f(%rip), %rdi      # 0xffffffff80112144
leaq 0x4c06(%rip), %rsi      # 0xffffffff801129b2
movl $0x13, %edx
leaq 0x4d4f(%rip), %rcx      # 0xffffffff80112b07
movb $0x0, %al
callq 0xffffffff80101e60
movl $0x0, -0xa18(%rbp)
movl -0xa18(%rbp), %eax
cmpl -0xa14(%rbp), %eax
je 0xffffffff8010de1e
movslq -0xa18(%rbp), %rax
leaq -0xa10(%rbp), %r8
shlq $0x8, %rax
addq %rax, %r8
leaq 0x4351(%rip), %rdi      # 0xffffffff80112144
leaq 0x4bb8(%rip), %rsi      # 0xffffffff801129b2
movl $0x15, %edx
leaq 0x4d21(%rip), %rcx      # 0xffffffff80112b27
movb $0x0, %al
callq 0xffffffff80101e60
movl -0xa18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa18(%rbp)
jmp 0xffffffff8010ddc9
jmp 0xffffffff8010de4f
movl -0xa14(%rbp), %edi
callq 0xffffffff8010d240
movq %rax, %r8
leaq 0x4344(%rip), %rdi      # 0xffffffff80112179
leaq 0x4b76(%rip), %rsi      # 0xffffffff801129b2
movl $0x17, %edx
leaq 0x4ce9(%rip), %rcx      # 0xffffffff80112b31
movb $0x0, %al
callq 0xffffffff80101e60
addq $0xa20, %rsp            # imm = 0xA20
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/krinkinmu[P]64bit/locking.c
// Function: _wait_queue_notify
static void __wait_queue_notify(struct wait_queue *queue)
{
	if (!list_empty(&queue->threads)) {
		struct list_head *ptr = list_first(&queue->threads);
		struct wait_head *wh = LIST_ENTRY(ptr, struct wait_head, link);

		list_del(ptr);
		activate_thread(wh->thread);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xffffffff801012f0
testb $0x1, %al
jne 0xffffffff8010df14
movq -0x8(%rbp), %rdi
callq 0xffffffff80101370
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xffffffff80101250
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xffffffff801084b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)