LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/parser.c
// Function: parsePrimitive
static void parsePrimitive()
{
    int primitiveNumber, argumentCount;

    if (nextToken() != intconst)
        compilError(selector, "primitive number missing", "");
    primitiveNumber = tokenInteger;
    nextToken();
    argumentCount = 0;
    while (parseok && !((token == binary) && streq(tokenString, ">")))
    {
        term();
        argumentCount++;
    }
    genInstruction(DoPrimitive, argumentCount);
    genCode(primitiveNumber);
    nextToken();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x8710
cmpl $0x3, %eax
je 0xaffc
leaq 0x1feb7(%rip), %rdi     # 0x2aea0
leaq 0x1b27(%rip), %rsi      # 0xcb17
leaq 0x16be(%rip), %rdx      # 0xc6b5
callq 0x64b0
leaq 0x1f54d(%rip), %rax     # 0x2a550
movl (%rax), %eax
movl %eax, -0x4(%rbp)
callq 0x8710
movl $0x0, -0x8(%rbp)
xorl %eax, %eax
cmpl $0x0, 0x1fd63(%rip)     # 0x2ad80
movb %al, -0x9(%rbp)
je 0xb057
xorl %eax, %eax
leaq 0x1f515(%rip), %rcx     # 0x2a540
cmpl $0x9, (%rcx)
movb %al, -0xa(%rbp)
jne 0xb04f
leaq 0x1f4b6(%rip), %rdi     # 0x2a4f0
leaq 0x105f(%rip), %rsi      # 0xc0a0
callq 0x2150
cmpl $0x0, %eax
sete %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
xorb $-0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xb060
jmp 0xb070
callq 0xa8e0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xb014
movl -0x8(%rbp), %esi
movl $0xd, %edi
callq 0x9650
movl -0x4(%rbp), %edi
callq 0xa750
callq 0x8710
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/unixio.c
// Function: fr
static int fr(FILE *fp, char *p, int s)
{
    int r;

    r = fread(p, s, 1, fp);
    if (r && (r != 1))
        sysError("imageRead count error", "");
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
movq -0x8(%rbp), %rcx
movl $0x1, %edx
callq 0x2060
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xb64b
cmpl $0x1, -0x18(%rbp)
je 0xb64b
leaq 0x1614(%rip), %rdi      # 0xcc53
leaq 0x106f(%rip), %rsi      # 0xc6b5
callq 0x63f0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/afi-lambda[P]a_little_smalltalk/src/unixio.c
// Function: imageWrite
void imageWrite(FILE *fp)
{
    short i, size;

    fw(fp, (char *) &symbols, sizeof(object));

    for (i = 0; i < ObjectTableMax; i++)
    {
        if (objectTable[i].referenceCount > 0)
        {
            dummyObject.di = i;
            dummyObject.cl = objectTable[i].STclass;
            dummyObject.ds = size = objectTable[i].size;
            fw(fp, (char *) &dummyObject, sizeof(dummyObject));
            if (size < 0)
                size = ((-size) + 1) / 2;
            if (size != 0)
                fw(fp, (char *) objectTable[i].memory, sizeof(object) * size);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1e23d(%rip), %rsi     # 0x298b4
movl $0x2, %edx
callq 0xb790
movw $0x0, -0xa(%rbp)
movswl -0xa(%rbp), %eax
cmpl $0x1964, %eax           # imm = 0x1964
jge 0xb77c
movswq -0xa(%rbp), %rcx
leaq 0x4bbe(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movswl 0x2(%rax), %eax
cmpl $0x0, %eax
jle 0xb769
movswl -0xa(%rbp), %eax
movl %eax, 0x20a30(%rip)     # 0x2c0f0
movswq -0xa(%rbp), %rcx
leaq 0x4b94(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movw (%rax), %ax
movw %ax, 0x20a17(%rip)      # 0x2c0f4
movswq -0xa(%rbp), %rcx
leaq 0x4b77(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movw 0x4(%rax), %ax
movw %ax, -0xc(%rbp)
movw %ax, 0x209f7(%rip)      # 0x2c0f6
movq -0x8(%rbp), %rdi
leaq 0x209e6(%rip), %rsi     # 0x2c0f0
movl $0x8, %edx
callq 0xb790
movswl -0xc(%rbp), %eax
cmpl $0x0, %eax
jge 0xb734
movswl -0xc(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movw %ax, -0xc(%rbp)
movswl -0xc(%rbp), %eax
cmpl $0x0, %eax
je 0xb767
movq -0x8(%rbp), %rdi
movswq -0xa(%rbp), %rcx
leaq 0x4b13(%rip), %rax      # 0x10260
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
movswq -0xc(%rbp), %rax
shlq %rax
movl %eax, %edx
callq 0xb790
jmp 0xb769
jmp 0xb76b
movw -0xa(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xa(%rbp)
jmp 0xb687
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/mkdb.c
// Function: initialize_bitmap
static int initialize_bitmap(struct db_header *bhdr, struct super_block *sb)
{
	int i;
	uint64_t dev_blockcnt = device_size(sb->s_bdev) >> sb->s_blocksize_bits;
	int blocks_count;
	struct db_bitmap *db_bitmap = load_all_bitmap(sb, dev_blockcnt, bhdr->db_bitmap_block);
	if (!db_bitmap)
		return -EIO;

	blocks_count = blocks_of_bitmap(sb, dev_blockcnt);

	bitmap_bits_set(db_bitmap, 0);
	printf("device block count: %" PRIu64 ", bitmap blocks count: %d\n", dev_blockcnt, blocks_count);
	for(i = 0;i < blocks_count;i++)
		bitmap_bits_set(db_bitmap, bhdr->db_bitmap_block + i);

	save_all_bitmap(sb, db_bitmap);
	free_all_bitmap(db_bitmap);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3ce0
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
shrq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0xc(%rax), %rdx
callq 0x54c0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2657
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x26d8
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5460
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5900
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq 0x7a0d(%rip), %rdi      # 0xa08f
movb $0x0, %al
callq 0x20a0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x26bb
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xc(%rax), %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
callq 0x5900
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2690
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x5800
movq -0x38(%rbp), %rdi
callq 0x5730
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/mkdb.c
// Function: main
int main(int argc, char **argv)
{
	int index = -1;
	int opt;
	struct arg_table argtbl;

	while ((opt = getopt(argc, argv, "n:f:")) != -1) {
		switch (opt) {
		case 'n':
			argtbl.size = atoll(optarg);
			break;
		case 'f':
			/* FIXME: Beware of overflowing!!!. */
			strcpy(argtbl.path, optarg);
			break;
		default:
			usage(argc, argv);
			exit(EXIT_FAILURE);
		}
		index++;
	}
	if (index < 0) {
		usage(argc, argv);
		exit(EXIT_FAILURE);
	}
	if (mkdb(&argtbl))
		exit(EXIT_FAILURE);

	exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x796c(%rip), %rdx      # 0xa08a
callq 0x2240
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
je 0x2799
movl -0x18(%rbp), %eax
movl %eax, -0x1024(%rbp)
subl $0x66, %eax
je 0x275d
jmp 0x273b
movl -0x1024(%rbp), %eax
subl $0x6e, %eax
jne 0x2775
jmp 0x2748
movq 0xb889(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
callq 0x2150
movq %rax, -0x20(%rbp)
jmp 0x278b
leaq -0x1020(%rbp), %rdi
movq 0xb86d(%rip), %rax      # 0xdfd8
movq (%rax), %rsi
callq 0x2050
jmp 0x278b
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x23c0
movl $0x1, %edi
callq 0x2260
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2710
cmpl $0x0, -0x14(%rbp)
jge 0x27b5
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x23c0
movl $0x1, %edi
callq 0x2260
leaq -0x1020(%rbp), %rdi
callq 0x23f0
cmpl $0x0, %eax
je 0x27d0
movl $0x1, %edi
callq 0x2260
xorl %edi, %edi
callq 0x2260
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/extents_bh.c
// Function: fs_bread
struct buffer_head *fs_bread(struct super_block *sb, ext4_fsblk_t block, int *ret)
{
	int err = 0;
	struct buffer_head *bh;
	bh = sb_getblk(sb, block);
	if (!bh)
		return NULL;

	err = bh_submit_read(bh);
	wait_on_buffer(bh);
	if (ret)
		*ret = err;

	fs_bh_alloc++;

	return bh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x28f0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x289d
movq $0x0, -0x8(%rbp)
jmp 0x28d9
movq -0x30(%rbp), %rdi
callq 0x3790
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2fe0
cmpq $0x0, -0x20(%rbp)
je 0x28c2
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl 0xb8d4(%rip), %eax      # 0xe19c
addl $0x1, %eax
movl %eax, 0xb8cb(%rip)      # 0xe19c
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/extents_bh.c
// Function: fs_bwrite
struct buffer_head *fs_bwrite(struct super_block *sb, ext4_fsblk_t block, int *ret)
{
	int err = 0;
	struct buffer_head *bh;
	bh = sb_getblk(sb, block);
	if (ret)
		*ret = err;

	if (bh)
		fs_bh_alloc++;

	return bh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x28f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x295c
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x2972
movl 0xb833(%rip), %eax      # 0xe19c
addl $0x1, %eax
movl %eax, 0xb82a(%rip)      # 0xe19c
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: device_open
int device_open(const char *path)
{
    int disk_fd = open(path, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR |
		    			     S_IRGRP |
					     S_IROTH);
    if (disk_fd < 0) {
        return -errno;
    }

    return disk_fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x42, %esi
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x2200
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x2bfb
callq 0x2040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x2c01
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: bdev_alloc
struct block_device *bdev_alloc(int fd, int blocksize_bits)
{
	struct block_device *bdev;
	struct super_block *super;

	bdev = xmalloc(sizeof(struct block_device) + sizeof(struct super_block));
	memset(bdev, 0,
	       sizeof(struct block_device) + sizeof(struct super_block));
	super = (struct super_block *)(bdev + 1);

	bdev->bd_fd = fd;
	bdev->bd_flags = 0;
	bdev->bd_super = super;

	INIT_LIST_HEAD(&bdev->bd_bh_free);
	INIT_LIST_HEAD(&bdev->bd_bh_dirty);
#ifndef USE_AIO
	INIT_LIST_HEAD(&bdev->bd_bh_ioqueue);
#endif
	pthread_mutex_init(&bdev->bd_bh_free_lock, NULL);
	pthread_mutex_init(&bdev->bd_bh_dirty_lock, NULL);
#ifndef USE_AIO
	pthread_mutex_init(&bdev->bd_bh_ioqueue_lock, NULL);
#endif
	pthread_mutex_init(&bdev->bd_bh_root_lock, NULL);

	super->s_blocksize_bits = blocksize_bits;
	super->s_blocksize = 1 << super->s_blocksize_bits;
	super->s_bdev = bdev;

	pipe(bdev->bd_bh_writeback_wakeup_fd);
	pthread_create(&bdev->bd_bh_writeback_thread, NULL,
			buffer_writeback_thread, bdev);

#ifndef USE_AIO
	pipe(bdev->bd_bh_io_wakeup_fd);
	pthread_create(&bdev->bd_bh_io_thread, NULL,
			buffer_io_thread, bdev);
#endif

	return bdev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x148, %edi            # imm = 0x148
callq 0x21c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x148, %edx            # imm = 0x148
callq 0x20d0
movq -0x10(%rbp), %rax
addq $0x128, %rax            # imm = 0x128
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x2d30
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
callq 0x2d30
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2290
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2290
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2290
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0x20f0
movq -0x10(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x4a(%rip), %rdx        # 0x2d60
callq 0x21f0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: buffer_writeback_thread
static void *buffer_writeback_thread(void *arg)
{
	struct epoll_event epev = {0};
	struct block_device *bdev = arg;
	int epfd = epoll_create(1);
	if (epfd < 0)
		return NULL;

	epev.events = EPOLLIN;
	epoll_ctl(epfd, EPOLL_CTL_ADD, bdev->bd_bh_writeback_wakeup_fd[0], &epev);

	while (1) {
		int ret;
		ret = epoll_wait(epfd, &epev, 1, buffer_writeback_ms);
		if (ret > 0) {
			/* We got an nofication. */
			signed char command;
			command = bdev_writeback_thread_read_notify(bdev);
			try_to_sync_buffers(bdev);
			if (bdev_is_notify_exiting(command))
				break;
			
			continue;
		}
		if (ret == 0) {
			/* just flush out the dirty data. */
			try_to_sync_buffers(bdev);
		}
		if (ret < 0 && errno != EINTR)
			break;

	}
	close(epfd);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0x20d0
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, %edi
callq 0x2250
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x2da4
movq $0x0, -0x8(%rbp)
jmp 0x2e40
movl $0x1, -0x1c(%rbp)
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rax
movl 0x120(%rax), %edx
movl $0x1, %esi
leaq -0x1c(%rbp), %rcx
callq 0x2110
movl -0x2c(%rbp), %edi
movl 0xb3a9(%rip), %ecx      # 0xe178
leaq -0x1c(%rbp), %rsi
movl $0x1, %edx
callq 0x21e0
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jle 0x2e0d
movq -0x28(%rbp), %rdi
callq 0x41f0
movb %al, -0x31(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4230
movsbl -0x31(%rbp), %edi
callq 0x4270
cmpl $0x0, %eax
je 0x2e0b
jmp 0x2e30
jmp 0x2dc6
cmpl $0x0, -0x30(%rbp)
jne 0x2e1c
movq -0x28(%rbp), %rdi
callq 0x4230
cmpl $0x0, -0x30(%rbp)
jge 0x2e2e
callq 0x2040
cmpl $0x4, (%rax)
je 0x2e2e
jmp 0x2e30
jmp 0x2dc6
movl -0x2c(%rbp), %edi
callq 0x20e0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: bdev_free
void bdev_free(struct block_device *bdev)
{
	struct rb_node *node;

	bdev_writeback_thread_notify_exit(bdev);
	pthread_join(bdev->bd_bh_writeback_thread, NULL);

#ifndef USE_AIO
	bdev_io_thread_notify_exit(bdev);
	pthread_join(bdev->bd_bh_io_thread, NULL);
#endif
	
	pthread_mutex_lock(&bdev->bd_bh_root_lock);
	while ((node = rb_first(&bdev->bd_bh_root))) {
		struct buffer_head *bh = rb_entry(
		    node, struct buffer_head, b_rb_node);
		wait_on_buffer(bh);
		detach_bh_from_freelist(bh);
		__buffer_remove(bdev, bh);
		buffer_free(bh);
	}
	pthread_mutex_unlock(&bdev->bd_bh_root_lock);

	if (bdev->bd_nr_free != 0)
		fprintf(stderr, "bdev->bd_nr_free == %d", bdev->bd_nr_free);

#ifndef USE_AIO
	close(bdev->bd_bh_io_wakeup_fd[0]);
	close(bdev->bd_bh_io_wakeup_fd[1]);
#endif

	close(bdev->bd_bh_writeback_wakeup_fd[0]);
	close(bdev->bd_bh_writeback_wakeup_fd[1]);

	pthread_mutex_destroy(&bdev->bd_bh_free_lock);
	pthread_mutex_destroy(&bdev->bd_bh_dirty_lock);
#ifndef USE_AIO
	pthread_mutex_destroy(&bdev->bd_bh_ioqueue_lock);
#endif
	pthread_mutex_destroy(&bdev->bd_bh_root_lock);

	xfree(bdev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fb0
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2280
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x22b0
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
callq 0x4fe0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x2eeb
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $-0x168, %rax           # imm = 0xFE98
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2fe0
movq -0x18(%rbp), %rdi
callq 0x3020
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x30a0
movq -0x18(%rbp), %rdi
callq 0x30e0
jmp 0x2e89
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x21b0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x2f24
movq 0xb0ec(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edx
leaq 0x71c6(%rip), %rsi      # 0xa0e3
movb $0x0, %al
callq 0x2170
movq -0x8(%rbp), %rax
movl 0x120(%rax), %edi
callq 0x20e0
movq -0x8(%rbp), %rax
movl 0x124(%rax), %edi
callq 0x20e0
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x20b0
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
callq 0x20b0
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x20b0
cmpq $0x0, -0x8(%rbp)
jne 0x2f90
movq 0xb07e(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x7176(%rip), %rsi      # 0xa0fa
movl $0x18c, %edx            # imm = 0x18C
movb $0x0, %al
callq 0x2170
cmpq $0x0, -0x8(%rbp)
je 0x2fa0
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: detach_bh_from_freelist
static void
detach_bh_from_freelist(struct buffer_head *bh)
{
	struct block_device *bdev = bh->b_bdev;
	if (!list_empty(&bh->b_freelist)) {
		pthread_mutex_lock(&bdev->bd_bh_free_lock);
		list_del_init(&bh->b_freelist);
		bh->b_bdev->bd_nr_free--;
		pthread_mutex_unlock(&bdev->bd_bh_free_lock);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x3d80
cmpl $0x0, %eax
jne 0x308e
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x22b0
movq -0x8(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x3da0
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x21b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: buffer_free
static void buffer_free(struct buffer_head *bh)
{
	sem_destroy(&bh->b_event);
	pthread_mutex_destroy(&bh->b_lock);

	if (bh->b_count != 0)
		fprintf(stderr, "bh: %p b_count != 0, my pid: %d", bh, getpid());

	xfree(bh);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0xd0, %rdi
callq 0x22a0
movq -0x8(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
callq 0x20b0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x108(%rax)
je 0x314c
movq 0xaed8(%rip), %rax      # 0xdff8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x2090
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl %eax, %ecx
leaq 0x7059(%rip), %rsi      # 0xa19e
movb $0x0, %al
callq 0x2170
cmpq $0x0, -0x8(%rbp)
jne 0x3170
movq 0xae9e(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x6f96(%rip), %rsi      # 0xa0fa
movl $0x1be, %edx            # imm = 0x1BE
movb $0x0, %al
callq 0x2170
cmpq $0x0, -0x8(%rbp)
je 0x3180
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: buffer_alloc
struct buffer_head *buffer_alloc(struct block_device *bdev, uint64_t block,
				 int page_size)
{
	struct buffer_head *bh;
	bh = xmalloc(sizeof(struct buffer_head) + page_size);
	if (!bh)
		return NULL;

	memset(bh, 0, sizeof(struct buffer_head));
	bh->b_bdev = bdev;
	bh->b_data = bh + 1;
	bh->b_size = page_size;
	bh->b_blocknr = block;
	bh->b_count = 0;
	bh->b_page = NULL;

	sem_init(&bh->b_event, 0, 1);

	pthread_mutex_init(&bh->b_lock, NULL);
	INIT_LIST_HEAD(&bh->b_freelist);
	INIT_LIST_HEAD(&bh->b_dirty_list);

#ifndef USE_AIO
	INIT_LIST_HEAD(&bh->b_io_list);
#endif

	sync_writeback_buffers(bdev);

	return bh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movslq -0x1c(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
callq 0x21c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x31cb
movq $0x0, -0x8(%rbp)
jmp 0x328b
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x180, %edx            # imm = 0x180
callq 0x20d0
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0xf0(%rax)
movq -0x28(%rbp), %rcx
addq $0x180, %rcx            # imm = 0x180
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movslq -0x1c(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x108(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rdi
addq $0xd0, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x21d0
movq -0x28(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
xorl %eax, %eax
movl %eax, %esi
callq 0x2290
movq -0x28(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x2d30
movq -0x28(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x2d30
movq -0x10(%rbp), %rdi
callq 0x32a0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: iocb_dispatch
void iocb_dispatch(union sigval value)
{
	struct buffer_head *bh = value.sival_ptr;
	int err;
	if (!bh)
		return;

	err = aio_error(&bh->b_aiocb);
	if (err < 0)
		bh->b_end_io(bh, 0);
	else
		bh->b_end_io(bh, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x32ed
jmp 0x332e
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x21a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x3318
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq *%rax
jmp 0x332e
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: after_buffer_sync
void after_buffer_sync(struct buffer_head *bh, int uptodate)
{
	if (uptodate)
		set_buffer_uptodate(bh);

	put_bh(bh);
	remove_buffer_from_writeback(bh);
	clear_buffer_dirty(bh);
	attach_bh_to_freelist(bh);
	unlock_buffer(bh);
	sem_post(&bh->b_event);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x34fe
movq -0x8(%rbp), %rdi
callq 0x3550
movq -0x8(%rbp), %rdi
callq 0x3570
movq -0x8(%rbp), %rdi
callq 0x3590
movq -0x8(%rbp), %rdi
callq 0x3600
movq -0x8(%rbp), %rdi
callq 0x3620
movq -0x8(%rbp), %rdi
callq 0x36b0
movq -0x8(%rbp), %rdi
addq $0xd0, %rdi
callq 0x2100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: remove_buffer_from_writeback
static void remove_buffer_from_writeback(struct buffer_head *bh)
{
	struct block_device *bdev = bh->b_bdev;
	pthread_mutex_lock(&bdev->bd_bh_dirty_lock);
	if (!list_empty(&bh->b_dirty_list)) {
		list_del_init(&bh->b_dirty_list);
		buffer_dirty_count--;
	}
	pthread_mutex_unlock(&bdev->bd_bh_dirty_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x22b0
movq -0x8(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x3d80
cmpl $0x0, %eax
jne 0x35ec
movq -0x8(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x3da0
movl 0xabc1(%rip), %eax      # 0xe1a4
addl $-0x1, %eax
movl %eax, 0xabb8(%rip)      # 0xe1a4
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x21b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: attach_bh_to_freelist
static void
attach_bh_to_freelist(struct buffer_head *bh)
{
	struct block_device *bdev = bh->b_bdev;
	if (list_empty(&bh->b_freelist)) {
		pthread_mutex_lock(&bdev->bd_bh_free_lock);
		list_add_tail(&bh->b_freelist, &bh->b_bdev->bd_bh_free);
		bh->b_bdev->bd_nr_free++;
		pthread_mutex_unlock(&bdev->bd_bh_free_lock);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x3d80
cmpl $0x0, %eax
je 0x369d
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x22b0
movq -0x8(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rsi
addq $0x48, %rsi
callq 0x3f00
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x21b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: after_buffer_write
void after_buffer_write(struct buffer_head *bh, int uptodate)
{
	if (uptodate)
		set_buffer_uptodate(bh);

	put_bh(bh);
	remove_buffer_from_writeback(bh);
	clear_buffer_dirty(bh);
	unlock_buffer(bh);
	sem_post(&bh->b_event);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x36fe
movq -0x8(%rbp), %rdi
callq 0x3550
movq -0x8(%rbp), %rdi
callq 0x3570
movq -0x8(%rbp), %rdi
callq 0x3590
movq -0x8(%rbp), %rdi
callq 0x3600
movq -0x8(%rbp), %rdi
callq 0x36b0
movq -0x8(%rbp), %rdi
addq $0xd0, %rdi
callq 0x2100
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: after_submit_read
void after_submit_read(struct buffer_head *bh, int uptodate)
{
	if (uptodate)
		set_buffer_uptodate(bh);

	put_bh(bh);
	unlock_buffer(bh);
	sem_post(&bh->b_event);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x375e
movq -0x8(%rbp), %rdi
callq 0x3550
movq -0x8(%rbp), %rdi
callq 0x3570
movq -0x8(%rbp), %rdi
callq 0x36b0
movq -0x8(%rbp), %rdi
addq $0xd0, %rdi
callq 0x2100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: bh_submit_read
int bh_submit_read(struct buffer_head *bh)
{
	int ret;

	lock_buffer(bh);
	if (buffer_uptodate(bh)) {
		unlock_buffer(bh);
		return 0;
	}

	get_bh(bh);
	clear_buffer_dirty(bh);
	remove_buffer_from_writeback(bh);
	bh->b_end_io = after_submit_read;
	ret = submit_bh(READ, bh);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3810
movq -0x10(%rbp), %rdi
callq 0x3840
cmpl $0x0, %eax
je 0x37c5
movq -0x10(%rbp), %rdi
callq 0x36b0
movl $0x0, -0x4(%rbp)
jmp 0x3806
movq -0x10(%rbp), %rdi
callq 0x3860
movq -0x10(%rbp), %rdi
callq 0x3600
movq -0x10(%rbp), %rdi
callq 0x3590
movq -0x10(%rbp), %rax
leaq -0xab(%rip), %rcx       # 0x3740
movq %rcx, 0xf8(%rax)
movq -0x10(%rbp), %rsi
xorl %edi, %edi
callq 0x34b0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: write_dirty_buffer
int write_dirty_buffer(struct buffer_head *bh)
{
	int ret = 0;

	if (!trylock_buffer(bh))
		return ret;

	if (buffer_dirty(bh)) {
		get_bh(bh);
		bh->b_end_io = after_buffer_write;
		ret = submit_bh(WRITE, bh);
	} else {
		unlock_buffer(bh);
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3900
cmpl $0x0, %eax
jne 0x38a9
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x38f4
movq -0x10(%rbp), %rdi
callq 0x3930
cmpl $0x0, %eax
je 0x38e5
movq -0x10(%rbp), %rdi
callq 0x3860
movq -0x10(%rbp), %rax
leaq -0x1eb(%rip), %rcx      # 0x36e0
movq %rcx, 0xf8(%rax)
movq -0x10(%rbp), %rsi
movl $0x1, %edi
callq 0x34b0
movl %eax, -0x14(%rbp)
jmp 0x38ee
movq -0x10(%rbp), %rdi
callq 0x36b0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: _getblk
struct buffer_head *__getblk(struct block_device *bdev, uint64_t block,
			     int bsize)
{
	struct buffer_head *bh;

	bh = buffer_search(bdev, block);
	if (bh) {
		detach_bh_from_freelist(bh);
		remove_buffer_from_writeback(bh);
		get_bh(bh);
		return bh;
	}
	bh = buffer_alloc(bdev, block, bsize);
	if (bh == NULL)
		return NULL;

	buffer_insert(bdev, bh);

	get_bh(bh);
	return bh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x39f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x39a0
movq -0x28(%rbp), %rdi
callq 0x3020
movq -0x28(%rbp), %rdi
callq 0x3590
movq -0x28(%rbp), %rdi
callq 0x3860
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x39e3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x3190
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x39c5
movq $0x0, -0x8(%rbp)
jmp 0x39e3
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3a50
movq -0x28(%rbp), %rdi
callq 0x3860
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: buffer_search
static struct buffer_head *buffer_search(struct block_device *bdev,
					 uint64_t blocknr)
{
	struct rb_root *root;
	struct buffer_head *bh;
	root = &bdev->bd_bh_root;
	pthread_mutex_lock(&bdev->bd_bh_root_lock);
	bh = __buffer_search(root, blocknr);
	pthread_mutex_unlock(&bdev->bd_bh_root_lock);

	return bh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x22b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3fb0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x21b0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: brelse
void brelse(struct buffer_head *bh)
{
	int refcount;
	if (bh == NULL)
		return;
	refcount = put_bh_and_read(bh);
	if (refcount >= 1)
		goto out;
	assert(refcount == 0);

	if (!buffer_dirty(bh))
		reclaim_buffer(bh);
	else
		move_buffer_to_writeback(bh);
out:
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3ac5
jmp 0x3b26
movq -0x8(%rbp), %rdi
callq 0x3b30
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0x3ad9
jmp 0x3b24
cmpl $0x0, -0xc(%rbp)
jne 0x3ae1
jmp 0x3b00
leaq 0x6632(%rip), %rdi      # 0xa11a
leaq 0x6639(%rip), %rsi      # 0xa128
movl $0x323, %edx            # imm = 0x323
leaq 0x6636(%rip), %rcx      # 0xa131
callq 0x20c0
movq -0x8(%rbp), %rdi
callq 0x3930
cmpl $0x0, %eax
jne 0x3b19
movq -0x8(%rbp), %rdi
callq 0x3b50
jmp 0x3b22
movq -0x8(%rbp), %rdi
callq 0x3b80
jmp 0x3b24
jmp 0x3b26
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: move_buffer_to_writeback
static void move_buffer_to_writeback(struct buffer_head *bh)
{
	struct block_device *bdev = bh->b_bdev;
	pthread_mutex_lock(&bdev->bd_bh_dirty_lock);
	if (list_empty(&bh->b_dirty_list)) {
		list_add_tail(&bh->b_dirty_list, &bh->b_bdev->bd_bh_dirty);
		buffer_dirty_count++;
	}
	pthread_mutex_unlock(&bdev->bd_bh_dirty_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x22b0
movq -0x8(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x3d80
cmpl $0x0, %eax
je 0x3bee
movq -0x8(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rsi
addq $0x80, %rsi
callq 0x3f00
movl 0xa5bf(%rip), %eax      # 0xe1a4
addl $0x1, %eax
movl %eax, 0xa5b6(%rip)      # 0xe1a4
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x21b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: simple_balloc
uint64_t simple_balloc(struct super_block *device, unsigned long blockcnt)
{
	struct stat64 buf;
	if(fstat64(device->s_bdev->bd_fd, &buf)) {
		perror("fstat64");
		printf("file size: %" PRIu64 "\n", buf.st_size);
		return 0;
	}
	if (posix_fallocate(device->s_bdev->bd_fd, buf.st_size, (uint64_t)blockcnt * device->s_blocksize)) {
		perror("fallocate64");
		printf("file size: %" PRIu64 ", request blockcnt: %lu\n", buf.st_size, blockcnt);
		return 0;
	}

	return buf.st_size / device->s_blocksize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %edi
leaq -0xa8(%rbp), %rsi
callq 0x2270
cmpl $0x0, %eax
je 0x3c66
leaq 0x650e(%rip), %rdi      # 0xa153
callq 0x2230
movq -0x78(%rbp), %rsi
leaq 0x6506(%rip), %rdi      # 0xa15b
movb $0x0, %al
callq 0x20a0
movq $0x0, -0x8(%rbp)
jmp 0x3cc7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %edi
movq -0x78(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
imulq (%rax), %rdx
callq 0x2190
cmpl $0x0, %eax
je 0x3cb6
leaq 0x64da(%rip), %rdi      # 0xa16b
callq 0x2230
movq -0x78(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x64d2(%rip), %rdi      # 0xa177
movb $0x0, %al
callq 0x20a0
movq $0x0, -0x8(%rbp)
jmp 0x3cc7
movq -0x78(%rbp), %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: device_size
uint64_t device_size(struct block_device *bdev)
{
	struct stat64 buf;
	if(fstat64(bdev->bd_fd, &buf)) {
		perror("fstat64");
		printf("file size: %" PRIu64 "\n", buf.st_size);
		return 0;
	}

	return buf.st_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0xa0(%rbp), %rsi
callq 0x2270
cmpl $0x0, %eax
je 0x3d2e
leaq 0x6446(%rip), %rdi      # 0xa153
callq 0x2230
movq -0x70(%rbp), %rsi
leaq 0x643e(%rip), %rdi      # 0xa15b
movb $0x0, %al
callq 0x20a0
movq $0x0, -0x8(%rbp)
jmp 0x3d36
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: _buffer_search
static struct buffer_head *__buffer_search(struct rb_root *root,
					   uint64_t blocknr)
{
	struct rb_node *new = root->rb_node;

	/* Figure out where to put new node */
	while (new) {
		struct buffer_head *bh =
		    container_of(new, struct buffer_head, b_rb_node);
		int64_t result = blocknr - bh->b_blocknr;

		if (result < 0)
			new = new->rb_left;
		else if (result > 0)
			new = new->rb_right;
		else
			return bh;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4034
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $-0x168, %rax           # imm = 0xFE98
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
subq 0x8(%rcx), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jge 0x4011
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4032
cmpq $0x0, -0x40(%rbp)
jle 0x4026
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4030
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x403c
jmp 0x4032
jmp 0x3fc7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: buffer_blocknr_cmp
static int buffer_blocknr_cmp(struct rb_node *a, struct rb_node *b)
{
	struct buffer_head *a_bh, *b_bh;
	a_bh = container_of(a, struct buffer_head, b_rb_node);
	b_bh = container_of(b, struct buffer_head, b_rb_node);

	if ((int64_t)(a_bh->b_blocknr - b_bh->b_blocknr) < 0)
		return -1;
	if ((int64_t)(a_bh->b_blocknr - b_bh->b_blocknr) > 0)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $-0x168, %rax           # imm = 0xFE98
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $-0x168, %rax           # imm = 0xFE98
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
subq 0x8(%rcx), %rax
cmpq $0x0, %rax
jge 0x40b7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40dd
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
subq 0x8(%rcx), %rax
cmpq $0x0, %rax
jle 0x40d6
movl $0x1, -0x4(%rbp)
jmp 0x40dd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: remove_first_bh_from_freelist
static void
remove_first_bh_from_freelist(struct block_device *bdev)
{
	struct buffer_head *bh;

	pthread_mutex_lock(&bdev->bd_bh_free_lock);
	if (list_empty(&bdev->bd_bh_free)) {
		pthread_mutex_unlock(&bdev->bd_bh_free_lock);
		return;
	}
	bh = list_first_entry(&bdev->bd_bh_free,
			      struct buffer_head, b_freelist);
	list_del_init(&bh->b_freelist);
	bh->b_bdev->bd_nr_free--;
	pthread_mutex_unlock(&bdev->bd_bh_free_lock);

	pthread_mutex_lock(&bdev->bd_bh_root_lock);
	__buffer_remove(bdev, bh);
	pthread_mutex_unlock(&bdev->bd_bh_root_lock);
	buffer_free(bh);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x22b0
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x3d80
cmpl $0x0, %eax
je 0x415d
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x21b0
jmp 0x41e6
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $-0x158, %rax           # imm = 0xFEA8
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x3da0
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x21b0
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x22b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x30a0
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x21b0
movq -0x10(%rbp), %rdi
callq 0x30e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: try_to_sync_buffers
static void try_to_sync_buffers(struct block_device *bdev)
{
	while (1) {
		struct buffer_head *cur;
		cur = remove_first_buffer_from_writeback(bdev);
		if (cur) {
			sync_dirty_buffer(cur);
			wait_on_buffer(cur);
		} else
			break;

	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4264
movq -0x10(%rbp), %rdi
callq 0x4350
movq -0x10(%rbp), %rdi
callq 0x2fe0
jmp 0x4266
jmp 0x4268
jmp 0x423c
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: remove_first_buffer_from_writeback
static struct buffer_head *
remove_first_buffer_from_writeback(struct block_device *bdev)
{
	struct buffer_head *bh;

	pthread_mutex_lock(&bdev->bd_bh_dirty_lock);
	if (list_empty(&bdev->bd_bh_dirty)) {
		pthread_mutex_unlock(&bdev->bd_bh_dirty_lock);
		return NULL;
	}
	bh = list_first_entry(&bdev->bd_bh_dirty,
			      struct buffer_head, b_dirty_list);
	list_del_init(&bh->b_dirty_list);
	buffer_dirty_count--;
	pthread_mutex_unlock(&bdev->bd_bh_dirty_lock);

	return bh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x22b0
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
callq 0x3d80
cmpl $0x0, %eax
je 0x42e5
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x21b0
movq $0x0, -0x8(%rbp)
jmp 0x433e
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $-0x148, %rax           # imm = 0xFEB8
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x3da0
movl 0x9e84(%rip), %eax      # 0xe1a4
addl $-0x1, %eax
movl %eax, 0x9e7b(%rip)      # 0xe1a4
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x21b0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/buffer.c
// Function: sync_dirty_buffer
static int sync_dirty_buffer(struct buffer_head *bh)
{
	int ret = 0;

	if (!trylock_buffer(bh))
		return ret;

	if (bh->b_count < 1 && buffer_dirty(bh)) {
		get_bh(bh);
		bh->b_end_io = after_buffer_sync;
		ret = submit_bh(WRITE, bh);
	} else {
		unlock_buffer(bh);
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3900
cmpl $0x0, %eax
jne 0x4379
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x43d1
movq -0x10(%rbp), %rax
cmpl $0x1, 0x108(%rax)
jge 0x43c2
movq -0x10(%rbp), %rdi
callq 0x3930
cmpl $0x0, %eax
je 0x43c2
movq -0x10(%rbp), %rdi
callq 0x3860
movq -0x10(%rbp), %rax
leaq -0xec8(%rip), %rcx      # 0x34e0
movq %rcx, 0xf8(%rax)
movq -0x10(%rbp), %rsi
movl $0x1, %edi
callq 0x34b0
movl %eax, -0x14(%rbp)
jmp 0x43cb
movq -0x10(%rbp), %rdi
callq 0x36b0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/rbtree.c
// Function: _rb_rotate_left
static void __rb_rotate_left(struct rb_node *node, struct rb_root *root)
{
	struct rb_node *right = node->rb_right;
	struct rb_node *parent = rb_parent(node);

	if ((node->rb_right = right->rb_left))
		rb_set_parent(right->rb_left, node);
	right->rb_left = node;

	rb_set_parent(right, parent);

	if (parent) {
		if (node == parent->rb_left)
			parent->rb_left = right;
		else
			parent->rb_right = right;
	} else
		root->rb_node = right;
	rb_set_parent(node, right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $-0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
je 0x4652
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4990
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4990
cmpq $0x0, -0x20(%rbp)
je 0x469c
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x468e
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x469a
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x46a7
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4990
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/rbtree.c
// Function: _rb_rotate_right
static void __rb_rotate_right(struct rb_node *node, struct rb_root *root)
{
	struct rb_node *left = node->rb_left;
	struct rb_node *parent = rb_parent(node);

	if ((node->rb_left = left->rb_right))
		rb_set_parent(left->rb_right, node);
	left->rb_right = node;

	rb_set_parent(left, parent);

	if (parent) {
		if (node == parent->rb_right)
			parent->rb_right = left;
		else
			parent->rb_left = left;
	} else
		root->rb_node = left;
	rb_set_parent(node, left);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $-0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0x4712
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4990
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4990
cmpq $0x0, -0x20(%rbp)
je 0x475c
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x474e
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x475a
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x4767
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4990
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/rbtree.c
// Function: rb_augment_insert
void rb_augment_insert(struct rb_node *node, rb_augment_f func,
			 void *data)
{
	if (node->rb_left)
		node = node->rb_left;
	else if (node->rb_right)
		node = node->rb_right;

	rb_augment_path(node, func, data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4d5d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4d76
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4d74
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4d76
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4d90
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)