LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/asc16.c
// Function: asc16_gylph_print
void asc16_gylph_print(char *d)
{
	int i, j;
	for (j = 0; j < ASC16_GYLPH_HEIGHT; j++, d++) {
		for (i = 0; i < ASC16_GYLPH_WIDTH; i++) {
			if (asc16_is_setpixel(d, i))
				printf("*");
			else
				printf(" ");
		}
		printf("\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x10, -0x10(%rbp)
jge 0x24f0
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x24cb
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl -0xc(%rbp), %ecx
movl $0x80, %edx
sarl %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x24b0
leaq 0x4b60(%rip), %rdi      # 0x7007
movb $0x0, %al
callq 0x1090
jmp 0x24be
leaq 0x5257(%rip), %rdi      # 0x770e
movb $0x0, %al
callq 0x1090
jmp 0x24c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2480
leaq 0x4b64(%rip), %rdi      # 0x7036
movb $0x0, %al
callq 0x1090
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2473
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/asc16.c
// Function: file_size
static inline int file_size(FILE *pf)
{
	int pos, size;

	pos = ftell(pf);
	if (pos == -1)
		return -1;

	if (fseek(pf, 0, SEEK_END) != 0)
		return -1;

	size = ftell(pf);
	if (size == -1)
		return -1;

	if (fseek(pf, pos, SEEK_SET) != 0)
		return -1;

	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10e0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x2527
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2585
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1110
cmpl $0x0, %eax
je 0x2547
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2585
movq -0x10(%rbp), %rdi
callq 0x10e0
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x2562
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2585
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
xorl %edx, %edx
callq 0x1110
cmpl $0x0, %eax
je 0x257f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2585
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: rbtree_save_as_bitmap
bitmap_t *rbtree_save_as_bitmap(rbtree_t *tree, asc16_t *asc16, int nil)
{
	bitmap_t *bitmap;
	draw_state_t st = { 0 };

	st.draw_nil = nil;
	dllist_init(&st.nils);

	bitmap = malloc(sizeof(bitmap_t));
	if (bitmap == NULL)
		return NULL;

	memset(bitmap, 0, sizeof(bitmap_t));

	st.bitmap = bitmap;
	st.asc16 = asc16;

	if (rbtree_foreach_preorder(tree, predraw, &st) != 0) {
		free(bitmap);
		free_draw_state(&st);
		return NULL;
	}

	calc_xy(&st);

	if (bitmap_init(bitmap, st.bitmapW, st.bitmapH, COLOR_WHITE) != 0) {
		free(bitmap);
		free_draw_state(&st);
		return NULL;
	}

	if (draw_rbtree(&st) != 0) {
		free(bitmap);
		free_draw_state(&st);
		return NULL;
	}

	free_draw_state(&st);

	return bitmap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x10b0
movl -0x1c(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x78(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x48(%rbp)
leaq -0x78(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x40(%rbp)
movl $0x10, %edi
callq 0x10f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2616
movq $0x0, -0x8(%rbp)
jmp 0x26e4
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10b0
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xbf(%rip), %rsi        # 0x2700
leaq -0x78(%rbp), %rdx
callq 0x1c50
cmpl $0x0, %eax
je 0x266b
movq -0x28(%rbp), %rdi
callq 0x1030
leaq -0x78(%rbp), %rdi
callq 0x2960
movq $0x0, -0x8(%rbp)
jmp 0x26e4
leaq -0x78(%rbp), %rdi
callq 0x2a70
movq -0x28(%rbp), %rdi
movl -0x64(%rbp), %esi
movl -0x60(%rbp), %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2e20
cmpl $0x0, %eax
je 0x26a9
movq -0x28(%rbp), %rdi
callq 0x1030
leaq -0x78(%rbp), %rdi
callq 0x2960
movq $0x0, -0x8(%rbp)
jmp 0x26e4
leaq -0x78(%rbp), %rdi
callq 0x2ec0
cmpl $0x0, %eax
je 0x26d3
movq -0x28(%rbp), %rdi
callq 0x1030
leaq -0x78(%rbp), %rdi
callq 0x2960
movq $0x0, -0x8(%rbp)
jmp 0x26e4
leaq -0x78(%rbp), %rdi
callq 0x2960
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: free_draw_state
static void free_draw_state(draw_state_t *st)
{
	dlitem_t *curr, *next;
	rbnil_t *nil;

	if (st) {
		free(st->rows);
		dllist_foreach(&st->nils, curr, next, rbnil_t, nil, dlentry) {
			dllist_remove(curr);
			if (rbnode_is_left(&nil->base.rbentry))
				nil->base.rbentry.parent->left = rbnode_nil;
			else if (rbnode_is_right(&nil->base.rbentry))
				nil->base.rbentry.parent->right = rbnode_nil;
			free_nil(nil);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2a68
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x40, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x30, %rcx
cmpq %rcx, %rax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x29c4
jmp 0x2a66
jmp 0x29c6
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jne 0x2a12
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq $0x0, 0x10(%rax)
jmp 0x2a39
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jne 0x2a37
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq $0x0, 0x18(%rax)
jmp 0x2a39
movq -0x20(%rbp), %rdi
callq 0x2590
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x40, %rax
movq %rax, -0x20(%rbp)
jmp 0x29a7
jmp 0x2a68
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: bitmap_init
int bitmap_init(bitmap_t *bitmap, int w, int h, color_t bg)
{
	int i;
	bitmap->w = w;
	bitmap->h = h;

	bitmap->colors = malloc(w * h * sizeof(color_t));
	if (bitmap->colors == NULL)
		return -1;
	for (i = 0; i < w * h; i++) {
		bitmap->colors[i] = bg;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x10f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2e7a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2eb3
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
imull -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x2eac
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2e81
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: draw_rbtree
static inline int draw_rbtree(draw_state_t *st)
{
	if (draw_lines(st) != 0)
		return -1;

	if (draw_rbnodes(st) != 0)
		return -1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4150
cmpl $0x0, %eax
je 0x2ee3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f01
movq -0x10(%rbp), %rdi
callq 0x4260
cmpl $0x0, %eax
je 0x2efa
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f01
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: bitmap_draw_point
int bitmap_draw_point(bitmap_t *bitmap, int x, int y, color_t c)
{
	int i = x + y * bitmap->w;
	if (i >= 0 && i < (bitmap->w * bitmap->h)) {
		bitmap->colors[i] = c;
		return 0;
	}
	else {
		errno = ERANGE;
		return -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rdx
imull (%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x2f9d
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movq -0x10(%rbp), %rdx
imull 0x4(%rdx), %ecx
cmpl %ecx, %eax
jge 0x2f9d
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl $0x0, -0x4(%rbp)
jmp 0x2faf
callq 0x1050
movl $0x22, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: draw_circle_8
static inline int draw_circle_8(bitmap_t *bitmap, int xc, int yc, int x, int y, color_t color)
{
	int r = 0;
	if (bitmap_draw_point(bitmap, xc + x, yc + y, color) != 0)
		r = -1;
	if (bitmap_draw_point(bitmap, xc - x, yc + y, color) != 0)
		r = -1;
	if (bitmap_draw_point(bitmap, xc + x, yc - y, color) != 0)
		r = -1;
	if (bitmap_draw_point(bitmap, xc - x, yc - y, color) != 0)
		r = -1;
	if (bitmap_draw_point(bitmap, xc + y, yc + x, color) != 0)
		r = -1;
	if (bitmap_draw_point(bitmap, xc - y, yc + x, color) != 0)
		r = -1;
	if (bitmap_draw_point(bitmap, xc + y, yc - x, color) != 0)
		r = -1;
	if (bitmap_draw_point(bitmap, xc - y, yc - x, color) != 0)
		r = -1;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
addl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x2f40
cmpl $0x0, %eax
je 0x3398
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
addl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x2f40
cmpl $0x0, %eax
je 0x33bc
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
subl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x2f40
cmpl $0x0, %eax
je 0x33e0
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
subl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x2f40
cmpl $0x0, %eax
je 0x3404
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl -0x18(%rbp), %esi
movl -0x10(%rbp), %edx
addl -0x14(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x2f40
cmpl $0x0, %eax
je 0x3428
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl -0x18(%rbp), %esi
movl -0x10(%rbp), %edx
addl -0x14(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x2f40
cmpl $0x0, %eax
je 0x344c
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl -0x18(%rbp), %esi
movl -0x10(%rbp), %edx
subl -0x14(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x2f40
cmpl $0x0, %eax
je 0x3470
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl -0x18(%rbp), %esi
movl -0x10(%rbp), %edx
subl -0x14(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x2f40
cmpl $0x0, %eax
je 0x3494
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: bitmap_draw_rect
int bitmap_draw_rect(bitmap_t *bitmap, int x0, int y0, int x1, int y1, int fill, color_t color)
{
	int x, y;
	int r = 0;
	if (fill) {
		for (y = y0; y < y1; y++) {
			for (x = x0; x <= x1; x++) {
				if (bitmap_draw_point(bitmap, x, y, color) != 0)
					r = -1;
			}
		}
	}
	else {
		for (x = x0; x <= x1; x++) {
			if (bitmap_draw_point(bitmap, x, y0, color) != 0)
				r = -1;
			if (bitmap_draw_point(bitmap, x, y1, color) != 0)
				r = -1;
		}
		for (y = y0; y < y1; y++) {
			if (bitmap_draw_point(bitmap, x0, y, color) != 0)
				r = -1;
			if (bitmap_draw_point(bitmap, x1, y, color) != 0)
				r = -1;
		}
	}

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x3526
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x3521
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x3514
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movl 0x10(%rbp), %ecx
callq 0x2f40
cmpl $0x0, %eax
je 0x3507
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
jmp 0x3509
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x34e1
jmp 0x3516
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x34d3
jmp 0x35d6
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x357d
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x10(%rbp), %edx
movl 0x10(%rbp), %ecx
callq 0x2f40
cmpl $0x0, %eax
je 0x3552
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x18(%rbp), %edx
movl 0x10(%rbp), %ecx
callq 0x2f40
cmpl $0x0, %eax
je 0x3570
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
jmp 0x3572
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x352c
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x35d4
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x24(%rbp), %edx
movl 0x10(%rbp), %ecx
callq 0x2f40
cmpl $0x0, %eax
je 0x35a9
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x24(%rbp), %edx
movl 0x10(%rbp), %ecx
callq 0x2f40
cmpl $0x0, %eax
je 0x35c7
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
jmp 0x35c9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3583
jmp 0x35d6
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: bitmap_draw_char
int bitmap_draw_char(bitmap_t *bitmap, int ch, int x, int y, color_t c, asc16_t *asc16)
{
	int i, j, r = 0;
	char *d;
	d = asc16_gylph_data(asc16, ch);
	for (j = 0; j < ASC16_GYLPH_HEIGHT; j++, d++) {
		for (i = 0; i < ASC16_GYLPH_WIDTH; i++) {
			if (asc16_is_setpixel(d, i))
				if (bitmap_draw_point(bitmap, x + i, y + j, c) != 0)
					r = -1;
		}
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
shll $0x4, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x10, -0x28(%rbp)
jge 0x369b
movl $0x0, -0x24(%rbp)
cmpl $0x8, -0x24(%rbp)
jge 0x3682
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
movl -0x24(%rbp), %ecx
movl $0x80, %edx
sarl %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x3675
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
addl -0x24(%rbp), %esi
movl -0x14(%rbp), %edx
addl -0x28(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x2f40
cmpl $0x0, %eax
je 0x3673
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
jmp 0x3675
jmp 0x3677
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x362f
jmp 0x3684
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x3622
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: bitmap_draw_string
int bitmap_draw_string(bitmap_t *bitmap, char *str, int x, int y, color_t c, asc16_t *asc16)
{
	int r = 0;
	while (*str) {
		if (bitmap_draw_char(bitmap, *str, x, y, c, asc16) != 0)
			r = -1;
		x += ASC16_ADVANCE;
		str++;
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x371f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl (%rax), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0x35e0
cmpl $0x0, %eax
je 0x3708
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x36d5
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: fwritei32
static inline int fwritei32(int v, FILE *pf)
{
	char buf[4];
	int r;
	buf[0] = v & 0xff;
	buf[1] = (v >> 8) & 0xff;
	buf[2] = (v >> 16) & 0xff;
	buf[3] = (v >> 24) & 0xff;
	r = fwrite(buf, 1, 4, pf);
	if (r != 4)
		return -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
andl $0xff, %eax
movb %al, -0x14(%rbp)
movl -0x8(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x13(%rbp)
movl -0x8(%rbp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, -0x12(%rbp)
movl -0x8(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movb %al, -0x11(%rbp)
leaq -0x14(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x1160
movl %eax, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
je 0x3aed
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3af4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: fwritei16
static inline int fwritei16(int v, FILE *pf)
{
	char buf[4];
	int r;
	buf[0] = v & 0xff;
	buf[1] = (v >> 8) & 0xff;
	r = fwrite(buf, 1, 2, pf);
	if (r != 2)
		return -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
andl $0xff, %eax
movb %al, -0x14(%rbp)
movl -0x8(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x13(%rbp)
leaq -0x14(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x2, %edx
callq 0x1160
movl %eax, -0x18(%rbp)
cmpl $0x2, -0x18(%rbp)
je 0x3b51
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3b58
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: fwritei24
static inline int fwritei24(int v, FILE *pf)
{
	char buf[4];
	int r;
	buf[0] = v & 0xff;
	buf[1] = (v >> 8) & 0xff;
	buf[2] = (v >> 16) & 0xff;
	r = fwrite(buf, 1, 3, pf);
	if (r != 3)
		return -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
andl $0xff, %eax
movb %al, -0x14(%rbp)
movl -0x8(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x13(%rbp)
movl -0x8(%rbp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, -0x12(%rbp)
leaq -0x14(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x3, %edx
callq 0x1160
movl %eax, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
je 0x3bcf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3bd6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: bitmap_save
int bitmap_save(bitmap_t *bitmap, const char *filename)
{
	FILE *pf;
	int r;

	pf = fopen(filename, "wb");
	if (pf == NULL)
		return -1;

	r = bitmap_print(bitmap, pf);

	fclose(pf);

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x3415(%rip), %rsi      # 0x7010
callq 0x1130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3c14
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3c33
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3730
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1070
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: new_nil
static rbnil_t *new_nil()
{
	rbnil_t *nil;

	nil = malloc(sizeof(rbnil_t));
	if (nil == NULL)
		return NULL;
	memset(nil, 0, sizeof(rbnil_t));
	nil->base.rbentry.key = itop(NIL_KEY);
	return nil;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x50, %edi
callq 0x10f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3f97
movq $0x0, -0x8(%rbp)
jmp 0x3fc3
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x10b0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3fd0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: get_radius
static int get_radius(int value)
{
	int r = 1;

	value /= 10;
	while (value != 0) {
		r++;
		value /= 10;
	}

	if (r < 3)
		r = 3;

	r *= ASC16_ADVANCE;
	r /= 2;

	r += CIRCLE_PADDING;

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x402b
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
jmp 0x400c
cmpl $0x3, -0x8(%rbp)
jge 0x4038
movl $0x3, -0x8(%rbp)
movl -0x8(%rbp), %eax
shll $0x3, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: move_x_fixup
static void move_x_fixup(draw_state_t *st, rbpoint_t *point)
{
	rbnode_t *n;
	rbpoint_t *m;
	dllist_t *list;
	int x;
	n = rbnode_is_nil(point->rbentry.left) ?
		point->rbentry.right :
		point->rbentry.left;
	if (!rbnode_is_nil(n)) {
		m = container_of(n, rbpoint_t, rbentry);
		if (m->x < point->x - 1) {
			x = point->x - 1 - m->x;
			m->x += x;
			list = st->rows + m->y;
			while (m->dlentry.next != &list->head) {
				m = container_of(m->dlentry.next, rbpoint_t, dlentry);
				m->x += x;
				move_x_fixup(st, m);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4089
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x4095
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4142
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x38(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x38(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4140
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
subl $0x1, %eax
movq -0x20(%rbp), %rcx
subl 0x38(%rcx), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
addl 0x38(%rax), %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x3c(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq %rcx, %rax
je 0x413e
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
addq $-0x28, %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
addl 0x38(%rax), %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4060
jmp 0x4101
jmp 0x4140
jmp 0x4142
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: draw_lines
static inline int draw_lines(draw_state_t *st)
{
	int i;
	dllist_t *list;
	dlitem_t *curr, *next;
	rbpoint_t *point;

	for (i = 0; i < st->rowcount; i++) {
		list = st->rows + i;
		dllist_foreach(list, curr, next, rbpoint_t, point, dlentry) {
			if (!rbnode_is_root(&point->rbentry)) {
				rbpoint_t *parent = container_of(point->rbentry.parent, rbpoint_t, rbentry);
				if (bitmap_draw_line(st->bitmap,
					parent->x, parent->y,
					point->x, point->y, LINE_COLOR) != 0)
					return -1;
			}
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x424f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $-0x28, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq %rcx, %rax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x41c2
jmp 0x423f
movq -0x38(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4219
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x40(%rbp), %rax
movl 0x38(%rax), %esi
movq -0x40(%rbp), %rax
movl 0x3c(%rax), %edx
movq -0x38(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x38(%rbp), %rax
movl 0x3c(%rax), %r8d
movl $0xff333333, %r9d       # imm = 0xFF333333
callq 0x2fc0
cmpl $0x0, %eax
je 0x4217
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4256
jmp 0x4219
jmp 0x421b
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $-0x28, %rax
movq %rax, -0x38(%rbp)
jmp 0x41ac
jmp 0x4241
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4163
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: draw_rbnodes
static inline int draw_rbnodes(draw_state_t *st)
{
	int i;
	dllist_t *list;
	dlitem_t *curr, *next;
	rbpoint_t *point;

	for (i = 0; i < st->rowcount; i++) {
		list = st->rows + i;
		dllist_foreach(list, curr, next, rbpoint_t, point, dlentry) {
			if (draw_rbnode(st, point) != 0)
				return -1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x4320
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $-0x28, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq %rcx, %rax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x42d2
jmp 0x4310
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4330
cmpl $0x0, %eax
je 0x42ed
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4327
jmp 0x42ef
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $-0x28, %rax
movq %rax, -0x38(%rbp)
jmp 0x42bc
jmp 0x4312
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4273
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: draw_rbnode
static inline int draw_rbnode(draw_state_t *st, rbpoint_t *point)
{
	if (ptoi(point->rbentry.key) == NIL_KEY) {
        return draw_nil(st->bitmap, point->x, point->y, st->asc16);
	}
	else {
		if (bitmap_draw_circle(st->bitmap,
			point->x, point->y,
			st->radius, 1,
			rbnode_is_red(&point->rbentry) ? COLOR_RED : COLOR_BLACK) != 0)
			return -1;

		if (draw_key(st, point) != 0)
			return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c40
cmpl $-0x1, %eax
jne 0x437c
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x38(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
callq 0x4430
movl %eax, -0x4(%rbp)
jmp 0x4424
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
je 0x43c3
movq -0x18(%rbp), %rax
cmpl $0x1, 0x8(%rax)
sete %al
movb %al, -0x19(%rbp)
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %esi
movq -0x30(%rbp), %rdi
movb -0x19(%rbp), %r8b
movl $0xff333333, %r9d       # imm = 0xFF333333
movl $0xffff3333, %eax       # imm = 0xFFFF3333
testb $0x1, %r8b
cmovnel %eax, %r9d
movl $0x1, %r8d
callq 0x31a0
cmpl $0x0, %eax
je 0x4400
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4424
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x44f0
cmpl $0x0, %eax
je 0x441b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4424
jmp 0x441d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: draw_nil
static inline int draw_nil(bitmap_t *bitmap, int x, int y, asc16_t *asc16)
{
    int x0, y0, x1, y1;
    x0 = x - (3 * ASC16_GYLPH_WIDTH / 2) - CIRCLE_PADDING;
    y0 = y - (ASC16_GYLPH_HEIGHT / 2);
    x1 = x0 + 3 * ASC16_GYLPH_WIDTH + CIRCLE_PADDING + CIRCLE_PADDING;
    y1 = y0 + ASC16_GYLPH_HEIGHT;
    if (bitmap_draw_rect(bitmap, x0, y0, x1, y1, 1, COLOR_BLACK) != 0)
        return -1;

    if (bitmap_draw_string(bitmap, "NIL", x0 + CIRCLE_PADDING + 1, y0 + 1, COLOR_WHITE, asc16) != 0)
        return -1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
subl $0xc, %eax
subl $0x2, %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x18, %eax
addl $0x2, %eax
addl $0x2, %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
addl $0x10, %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r8d
movl $0x1, %r9d
movl $0xff333333, (%rsp)     # imm = 0xFF333333
callq 0x34a0
cmpl $0x0, %eax
je 0x44a4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x44e2
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %edx
addl $0x2, %edx
addl $0x1, %edx
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %r9
leaq 0x2b51(%rip), %rsi      # 0x7013
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x36b0
cmpl $0x0, %eax
je 0x44db
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x44e2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/bitmap.c
// Function: draw_key
static inline int draw_key(draw_state_t *st, rbpoint_t *point)
{
	int w;
	char *key;

	key = keytostr(point->rbentry.key);

	w = strlen(key) * ASC16_ADVANCE;

	if (bitmap_draw_string(st->bitmap, key,
		point->x - w / 2 + 1, point->y - ASC16_GYLPH_HEIGHT / 2 + 1,
		COLOR_WHITE, st->asc16) != 0)
		return -1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x4590
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1080
shlq $0x3, %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl -0x2c(%rbp), %edx
subl %eax, %edx
addl $0x1, %edx
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %ecx
subl $0x8, %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %r9
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x36b0
cmpl $0x0, %eax
je 0x4577
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x457e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/test.c
// Function: insert
static void insert(int v)
{
	rbpoint_t *point;

	if (v < 0) {
		printf("insert %d error: require positive integer.\n", v);
		return;
	}

	point = malloc(sizeof(rbpoint_t));
	if (point == NULL) {
		printf("insert %d error: alloc.\n", v);
		return;
	}
	memset(point, 0, sizeof(rbpoint_t));
	point->rbentry.key = itop(v);
	if (rbtree_insert(&tree, &point->rbentry) == 0) {
		printf("insert %d.\n", v);
		entries++;
	}
	else {
		printf("insert %d error: exist.\n", v);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x4c17
movl -0x4(%rbp), %esi
leaq 0x2621(%rip), %rdi      # 0x722c
movb $0x0, %al
callq 0x1090
jmp 0x4ca9
movl $0x40, %edi
callq 0x10f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4c3f
movl -0x4(%rbp), %esi
leaq 0x2622(%rip), %rdi      # 0x7258
movb $0x0, %al
callq 0x1090
jmp 0x4ca9
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x10b0
movl -0x4(%rbp), %edi
callq 0x5280
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
leaq 0x5464(%rip), %rdi      # 0xa0d0
callq 0x1280
cmpl $0x0, %eax
jne 0x4c98
movl -0x4(%rbp), %esi
leaq 0x25f1(%rip), %rdi      # 0x7271
movb $0x0, %al
callq 0x1090
movl 0x54f3(%rip), %eax      # 0xa180
addl $0x1, %eax
movl %eax, 0x54ea(%rip)      # 0xa180
jmp 0x4ca9
movl -0x4(%rbp), %esi
leaq 0x25db(%rip), %rdi      # 0x727d
movb $0x0, %al
callq 0x1090
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/test.c
// Function: delete
static void delete(int v)
{
	rbnode_t *n;
	rbpoint_t *point;
	n = rbtree_lookup(&tree, itop(v));
	if (n == NULL) {
		printf("%d not exist.\n", v);
	}
	else {
		point = container_of(n, rbpoint_t, rbentry);
		rbtree_remove(&tree, n);
		printf("delete %d\n", ptoi(n->key));
		free_point(point);
		entries--;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x5280
movq %rax, %rsi
leaq 0x5403(%rip), %rdi      # 0xa0d0
callq 0x1600
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4cf0
movl -0x4(%rbp), %esi
leaq 0x25af(%rip), %rdi      # 0x7296
movb $0x0, %al
callq 0x1090
jmp 0x4d3c
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x53cd(%rip), %rdi      # 0xa0d0
callq 0x1680
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x52e0
movl %eax, %esi
leaq 0x2588(%rip), %rdi      # 0x72a5
movb $0x0, %al
callq 0x1090
movq -0x18(%rbp), %rdi
callq 0x5300
movl 0x544d(%rip), %eax      # 0xa180
addl $-0x1, %eax
movl %eax, 0x5444(%rip)      # 0xa180
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/test.c
// Function: lookup
static void lookup(int v)
{
	rbnode_t *n;
	n = rbtree_lookup(&tree, itop(v));
	if (n == NULL) {
		printf("%d not exist.\n", v);
	}
	else {
		print_node(&tree, n, NULL);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x5280
movq %rax, %rsi
leaq 0x5363(%rip), %rdi      # 0xa0d0
callq 0x1600
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4d90
movl -0x4(%rbp), %esi
leaq 0x250f(%rip), %rdi      # 0x7296
movb $0x0, %al
callq 0x1090
jmp 0x4da4
movq -0x10(%rbp), %rsi
leaq 0x5335(%rip), %rdi      # 0xa0d0
xorl %eax, %eax
movl %eax, %edx
callq 0x5320
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/test.c
// Function: do_print
static void do_print(const char *opt)
{
	printf("parent node color   dir    x    y\n");
	if (opt == NULL)
		rbtree_foreach_print(&tree, print_node, NULL);
	else if (strcmp("pre", opt) == 0)
		rbtree_foreach_preorder(&tree, print_node, NULL);
	else if (strcmp("in", opt) == 0)
		rbtree_foreach_inorder(&tree, print_node, NULL);
	else if (strcmp("post", opt) == 0)
		rbtree_foreach_postorder(&tree, print_node, NULL);
	else {
		if (strlen(opt) != 0) {
			printf("warning: unknow print option \"%s\", print in default mode.\n", opt);
		}
		rbtree_foreach_print(&tree, print_node, NULL);
	}

	printf("%d entries.\n", entries);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2531(%rip), %rdi      # 0x72f4
movb $0x0, %al
callq 0x1090
cmpq $0x0, -0x8(%rbp)
jne 0x4ded
leaq 0x52f8(%rip), %rdi      # 0xa0d0
leaq 0x541(%rip), %rsi       # 0x5320
xorl %eax, %eax
movl %eax, %edx
callq 0x1f20
jmp 0x4eb8
movq -0x8(%rbp), %rsi
leaq 0x234d(%rip), %rdi      # 0x7145
callq 0x10c0
cmpl $0x0, %eax
jne 0x4e1e
leaq 0x52c7(%rip), %rdi      # 0xa0d0
leaq 0x510(%rip), %rsi       # 0x5320
xorl %eax, %eax
movl %eax, %edx
callq 0x1c50
jmp 0x4eb6
movq -0x8(%rbp), %rsi
leaq 0x2320(%rip), %rdi      # 0x7149
callq 0x10c0
cmpl $0x0, %eax
jne 0x4e4c
leaq 0x5296(%rip), %rdi      # 0xa0d0
leaq 0x4df(%rip), %rsi       # 0x5320
xorl %eax, %eax
movl %eax, %edx
callq 0x1d40
jmp 0x4eb4
movq -0x8(%rbp), %rsi
leaq 0x22f5(%rip), %rdi      # 0x714c
callq 0x10c0
cmpl $0x0, %eax
jne 0x4e7a
leaq 0x5268(%rip), %rdi      # 0xa0d0
leaq 0x4b1(%rip), %rsi       # 0x5320
xorl %eax, %eax
movl %eax, %edx
callq 0x1e30
jmp 0x4eb2
movq -0x8(%rbp), %rdi
callq 0x1080
cmpq $0x0, %rax
je 0x4e9b
movq -0x8(%rbp), %rsi
leaq 0x2483(%rip), %rdi      # 0x7317
movb $0x0, %al
callq 0x1090
leaq 0x522e(%rip), %rdi      # 0xa0d0
leaq 0x477(%rip), %rsi       # 0x5320
xorl %eax, %eax
movl %eax, %edx
callq 0x1f20
jmp 0x4eb4
jmp 0x4eb6
jmp 0x4eb8
movl 0x52c2(%rip), %esi      # 0xa180
leaq 0x257e(%rip), %rdi      # 0x7443
movb $0x0, %al
callq 0x1090
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/test.c
// Function: do_load
static void do_load(const char *path)
{
	FILE *pf;
	char buf[1024];
	int r, i, ch, v;

	printf("Loading from %s ...\n", path);

	pf = fopen(path, "rb");
	if (pf == NULL) {
		printf("Can't open the file %s.\n", path);
		return;
	}

	v = -1;

	while ((r = fread(buf, 1, sizeof(buf), pf)) > 0) {
		for (i = 0; i < r; i++) {
			ch = buf[i];
			if (isspace(ch)) {
				if (v >= 0) {
					insert(v);
					v = -1;
				}
			}
			else if (!isdigit(ch)) {
				printf("Invalid file format %s.\n", path);
				fclose(pf);
				return;
			}
			else {
				if (v == -1)
					v = ch - '0';
				else {
					v *= 10;
					v += ch - '0';
				}
			}
		}
	}

	if (v >= 0) {
		insert(v);
		v = -1;
	}

	fclose(pf);

	printf("%d entries.\n", entries);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x2458(%rip), %rdi      # 0x7352
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rdi
leaq 0x20f8(%rip), %rsi      # 0x7004
callq 0x1130
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4f33
movq -0x8(%rbp), %rsi
leaq 0x2440(%rip), %rdi      # 0x7367
movb $0x0, %al
callq 0x1090
jmp 0x50a7
movl $0xffffffff, -0x420(%rbp) # imm = 0xFFFFFFFF
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x1060
movl %eax, -0x414(%rbp)
cmpl $0x0, %eax
jle 0x506c
movl $0x0, -0x418(%rbp)
movl -0x418(%rbp), %eax
cmpl -0x414(%rbp), %eax
jge 0x5067
movslq -0x418(%rbp), %rax
movsbl -0x410(%rbp,%rax), %eax
movl %eax, -0x41c(%rbp)
callq 0x1170
movq (%rax), %rax
movslq -0x41c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x4fd4
cmpl $0x0, -0x420(%rbp)
jl 0x4fd2
movl -0x420(%rbp), %edi
callq 0x4bf0
movl $0xffffffff, -0x420(%rbp) # imm = 0xFFFFFFFF
jmp 0x5051
callq 0x1170
movq (%rax), %rax
movslq -0x41c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x5011
movq -0x8(%rbp), %rsi
leaq 0x2384(%rip), %rdi      # 0x7380
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x1070
jmp 0x50a7
cmpl $-0x1, -0x420(%rbp)
jne 0x502b
movl -0x41c(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x420(%rbp)
jmp 0x504d
imull $0xa, -0x420(%rbp), %eax
movl %eax, -0x420(%rbp)
movl -0x41c(%rbp), %eax
subl $0x30, %eax
addl -0x420(%rbp), %eax
movl %eax, -0x420(%rbp)
jmp 0x504f
jmp 0x5051
jmp 0x5053
movl -0x418(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x418(%rbp)
jmp 0x4f70
jmp 0x4f3d
cmpl $0x0, -0x420(%rbp)
jl 0x508a
movl -0x420(%rbp), %edi
callq 0x4bf0
movl $0xffffffff, -0x420(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
callq 0x1070
movl 0x50e7(%rip), %esi      # 0xa180
leaq 0x23a3(%rip), %rdi      # 0x7443
movb $0x0, %al
callq 0x1090
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/test.c
// Function: do_save
static void do_save(const char *path)
{
	FILE *pf;
	int r;
	struct save_state ss = { 0 };

	printf("Saving to %s ...\n", path);

	pf = fopen(path, "wb");
	if (pf == NULL) {
		printf("Can't open the file %s.\n", path);
		return;
	}

	ss.pf = pf;
	ss.i = 0;

	r = rbtree_foreach_inorder(&tree, save_node, &ss);
	if (r != 0)
		printf("Failed to write file %s.\n", path);

	fclose(pf);

	printf("%d entries.\n", entries);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10b0
movq -0x8(%rbp), %rsi
leaq 0x22c2(%rip), %rdi      # 0x7399
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rdi
leaq 0x1f27(%rip), %rsi      # 0x7010
callq 0x1130
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x510d
movq -0x8(%rbp), %rsi
leaq 0x2263(%rip), %rdi      # 0x7367
movb $0x0, %al
callq 0x1090
jmp 0x516b
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
leaq 0x4fad(%rip), %rdi      # 0xa0d0
leaq 0x396(%rip), %rsi       # 0x54c0
leaq -0x28(%rbp), %rdx
callq 0x1d40
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x514e
movq -0x8(%rbp), %rsi
leaq 0x2264(%rip), %rdi      # 0x73ab
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x1070
movl 0x5023(%rip), %esi      # 0xa180
leaq 0x22df(%rip), %rdi      # 0x7443
movb $0x0, %al
callq 0x1090
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/test.c
// Function: do_bmp
static void do_bmp(const char *path, int nil)
{
	bitmap_t *bitmap;
	printf("Creating bitmap...\n");

	bitmap = rbtree_save_as_bitmap(&tree, &asc16, nil);

	if (bitmap == NULL) {
		printf("Failed to create bitmap.\n");
		return;
	}

	if (path && strlen(path) > 0) {
		if (bitmap_save(bitmap, path) != 0) {
			bitmap_free(bitmap);
			printf("Failed to save bitmap to file %s.\n", path);
			return;
		}
	}
	else {
		if (bitmap_print(bitmap, stdout) != 0) {
			bitmap_free(bitmap);
			printf("Failed to print bitmap to \"stdout\".\n");
			return;
		}
		printf("\n");
	}

	bitmap_free(bitmap);

	printf("Done. %d entries.\n", entries);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x2231(%rip), %rdi      # 0x73c7
movb $0x0, %al
callq 0x1090
movl -0xc(%rbp), %edx
leaq 0x4f29(%rip), %rdi      # 0xa0d0
leaq 0x4fc2(%rip), %rsi      # 0xa170
callq 0x25b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x51d1
leaq 0x2216(%rip), %rdi      # 0x73db
movb $0x0, %al
callq 0x1090
jmp 0x5274
cmpq $0x0, -0x8(%rbp)
je 0x5218
movq -0x8(%rbp), %rdi
callq 0x1080
cmpq $0x0, %rax
jbe 0x5218
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3be0
cmpl $0x0, %eax
je 0x5216
movq -0x18(%rbp), %rdi
callq 0x2f10
movq -0x8(%rbp), %rsi
leaq 0x21e8(%rip), %rdi      # 0x73f5
movb $0x0, %al
callq 0x1090
jmp 0x5274
jmp 0x5257
movq -0x18(%rbp), %rdi
movq 0x4db5(%rip), %rax      # 0x9fd8
movq (%rax), %rsi
callq 0x3730
cmpl $0x0, %eax
je 0x5249
movq -0x18(%rbp), %rdi
callq 0x2f10
leaq 0x21d8(%rip), %rdi      # 0x7418
movb $0x0, %al
callq 0x1090
jmp 0x5274
leaq 0x1de6(%rip), %rdi      # 0x7036
movb $0x0, %al
callq 0x1090
movq -0x18(%rbp), %rdi
callq 0x2f10
movl 0x4f1a(%rip), %esi      # 0xa180
leaq 0x21d0(%rip), %rdi      # 0x743d
movb $0x0, %al
callq 0x1090
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/test.c
// Function: print_node
static int print_node(rbtree_t *tree, rbnode_t *n, void *state)
{
	rbpoint_t *point = container_of(n, rbpoint_t, rbentry);
	if (n->parent == NULL) {
		printf("       %4d %5s       %4d %4d\n", ptoi(n->key),
			n->color == rbnode_red ? "r" : "b",
			point->x, point->y);
	}
	else {
		printf("%6d %4d %5s %5s %4d %4d\n",
			ptoi(n->parent->key),
			ptoi(n->key),
			n->color == rbnode_red ? "r" : "b",
			n->parent->right == n ? "r" : "l",
			point->x, point->y);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x5393
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x52e0
movl %eax, %esi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0x1ca2(%rip), %rdx      # 0x7005
leaq 0x1dd1(%rip), %rax      # 0x713b
cmpl $0x1, %ecx
cmoveq %rax, %rdx
movq -0x20(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x20(%rbp), %rax
movl 0x3c(%rax), %r8d
leaq 0x1f29(%rip), %rdi      # 0x72b0
movb $0x0, %al
callq 0x1090
jmp 0x5418
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdi
callq 0x52e0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x52e0
movl -0x24(%rbp), %esi
movl %eax, %edx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
leaq 0x1c40(%rip), %rcx      # 0x7005
leaq 0x1d6f(%rip), %rax      # 0x713b
cmpl $0x1, %edi
cmoveq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %r9
leaq 0x1df7(%rip), %r8       # 0x71e1
leaq 0x1d4a(%rip), %rax      # 0x713b
cmpq %r9, %rdi
cmoveq %rax, %r8
movq -0x20(%rbp), %rax
movl 0x38(%rax), %r9d
movq -0x20(%rbp), %rax
movl 0x3c(%rax), %eax
leaq 0x1ec0(%rip), %rdi      # 0x72ce
movl %eax, (%rsp)
movb $0x0, %al
callq 0x1090
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/test.c
// Function: do_clean
static void do_clean()
{
	printf("Cleaning...\n");
	free_rbtree(&tree);
	rbtree_init(&tree, keycmp);
	entries = 0;
	printf("%d entries.\n", entries);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1ebc(%rip), %rdi      # 0x72e7
movb $0x0, %al
callq 0x1090
leaq 0x4c97(%rip), %rdi      # 0xa0d0
leaq 0x50(%rip), %rsi        # 0x5490
xorl %eax, %eax
movl %eax, %edx
callq 0x1e30
movq $0x0, 0x4c7c(%rip) # 0xa0d0
leaq -0x1bb(%rip), %rax      # 0x52a0
movq %rax, 0x4c76(%rip)      # 0xa0d8
movl $0x0, 0x4d14(%rip)      # 0xa180
movl 0x4d0e(%rip), %esi      # 0xa180
leaq 0x1fca(%rip), %rdi      # 0x7443
movb $0x0, %al
callq 0x1090
popq %rbp
retq
nopw %cs:(%rax,%rax)