LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movl %edx, %r14d
movq %rdi, %r15
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
imull %esi, %r14d
movslq %r14d, %rdi
shlq $0x2, %rdi
callq 0x1110
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x2178
movq %rax, %rcx
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
xorl %edx, %edx
cmpq %rdx, %r14
je 0x217b
movl %ebx, (%rcx,%rdx,4)
incq %rdx
jmp 0x216b
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rdi), %eax
imull %eax, %edx
addl %esi, %edx
js 0x21ad
imull 0x4(%rdi), %eax
cmpl %eax, %edx
jge 0x21ad
movq 0x8(%rdi), %rax
movl %edx, %edx
movl %ecx, (%rax,%rdx,4)
xorl %eax, %eax
retq
pushq %rax
callq 0x1060
movl $0x22, (%rax)
pushq $-0x1
popq %rax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]rbtree/test/bitmap.c
// Function: bitmap_draw_line
int bitmap_draw_line(bitmap_t *bitmap, int x1, int y1, int x2, int y2, color_t color)
{
	int ix, iy, cx, cy, n2dy, n2dydx, d;
	int dx, dy, yy;
	int r = 0;
	
	dx = abs(x2 - x1);
	dy = abs(y2 - y1);
	yy = 0;

	if (dx < dy) {
		yy = 1;
		swap_int(&x1, &y1);
		swap_int(&x2, &y2);
		swap_int(&dx, &dy);
	}

	ix = (x2 - x1) > 0 ? 1 : -1;
	iy = (y2 - y1) > 0 ? 1 : -1;
	cx = x1;
	cy = y1;
	n2dy = dy * 2;
	n2dydx = (dy - dx) * 2;
	d = dy * 2 - dx;

	if (yy) { /* ����ֱ���� x ���ļнǴ��� 45 �� */
		while (cx != x2) {
			if (d < 0) {
				d += n2dy;
			}
			else {
				cy += iy;
				d += n2dydx;
			}
			if (bitmap_draw_point(bitmap, cy, cx, color) != 0)
				r = -1;
			cx += ix;
		}
	}
	else { /* ����ֱ���� x ���ļн�С�� 45 �� */
		while (cx != x2) {
			if (d < 0) {
				d += n2dy;
			}
			else {
				cy += iy;
				d += n2dydx;
			}
			if (bitmap_draw_point(bitmap, cx, cy, color) != 0)
				r = -1;
			cx += ix;
		}
	}

	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0xc(%rsp)
movl %esi, %ebp
movl %ecx, %esi
subl %ebp, %esi
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
movq %rdi, 0x10(%rsp)
movl %r8d, %edi
subl %edx, %edi
movl %edi, %esi
negl %esi
cmovsl %edi, %esi
cmpl %esi, %eax
jae 0x2203
movl %edx, %r15d
movl %r8d, %r9d
movl %esi, %edx
movl %eax, %r10d
jmp 0x2213
movl %ebp, %r15d
movl %edx, %ebp
movl %ecx, %r9d
movl %r8d, %ecx
movl %eax, %edx
movl %esi, %r10d
xorl %edi, %edi
cmpl %r15d, %r9d
setg %dil
xorl %r8d, %r8d
cmpl %ebp, %ecx
setg %r8b
leal (%r10,%r10), %r14d
subl %edx, %r10d
addl %r10d, %r10d
movl %r14d, 0x8(%rsp)
subl %edx, %r14d
leal -0x1(,%rdi,2), %ecx
movl %ecx, 0x4(%rsp)
leal -0x1(,%r8,2), %ecx
movl %ecx, (%rsp)
cmpl %esi, %eax
movl %r9d, %ebx
movq %r10, %r13
jae 0x22aa
xorl %r12d, %r12d
cmpl %r15d, %r9d
je 0x22f9
testl %r14d, %r14d
movl (%rsp), %eax
movl $0x0, %ecx
cmovsl %ecx, %eax
movl %r10d, %ecx
cmovsl 0x8(%rsp), %ecx
addl %eax, %ebp
addl %ecx, %r14d
movq 0x10(%rsp), %rdi
movl %ebp, %esi
movl %r15d, %edx
movl 0xc(%rsp), %ecx
callq 0x2190
movq %r13, %r10
movl %ebx, %r9d
negl %eax
movl $0x0, %eax
sbbl %eax, %eax
orl %eax, %r12d
addl 0x4(%rsp), %r15d
jmp 0x225a
xorl %r12d, %r12d
cmpl %r15d, %r9d
je 0x22f9
testl %r14d, %r14d
movl (%rsp), %eax
movl $0x0, %ecx
cmovsl %ecx, %eax
movl %r10d, %ecx
cmovsl 0x8(%rsp), %ecx
addl %eax, %ebp
addl %ecx, %r14d
movq 0x10(%rsp), %rdi
movl %r15d, %esi
movl %ebp, %edx
movl 0xc(%rsp), %ecx
callq 0x2190
movq %r13, %r10
movl %ebx, %r9d
negl %eax
movl $0x0, %eax
sbbl %eax, %eax
orl %eax, %r12d
addl 0x4(%rsp), %r15d
jmp 0x22ad
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]rbtree/test/bitmap.c
// Function: bitmap_draw_circle
int bitmap_draw_circle(bitmap_t *bitmap, int xc, int yc, int r, int fill, color_t c)
{
	int x = 0, y = r, yi, d;
	int rc = 0;

	/* ����Բ��ͼƬ�ɼ������⣬ֱ���˳� */
	if (xc + r < 0 || xc - r >= bitmap->w ||
		yc + r < 0 || yc - r >= bitmap->h) {
		errno = ERANGE;
		return -1;
	}

	d = 3 - 2 * r;

	if (fill) {
		/* �������䣨��ʵ��Բ��*/
		while (x <= y) {
			for (yi = x; yi <= y; yi++) {
				if (draw_circle_8(bitmap, xc, yc, x, yi, c) != 0)
					rc = -1;
			}

			if (d < 0) {
				d = d + 4 * x + 6;
			}
			else {
				d = d + 4 * (x - y) + 10;
				y--;
			}
			x++;
		}
	}
	else {
		/* ���������䣨������Բ��*/
		while (x <= y) {
			if (draw_circle_8(bitmap, xc, yc, x, y, c) != 0)
				rc = -1;

			if (d < 0) {
				d = d + 4 * x + 6;
			}
			else {
				d = d + 4 * (x - y) + 10;
				y--;
			}
			x++;
		}
	}

	return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0x1c(%rsp)
movl %ecx, %eax
addl %esi, %eax
js 0x23fd
movl %esi, %eax
subl %ecx, %eax
cmpl (%rdi), %eax
setge %al
movl %ecx, %r9d
addl %edx, %r9d
sets %r9b
orb %al, %r9b
jne 0x23fd
movl %edx, %eax
subl %ecx, %eax
cmpl 0x4(%rdi), %eax
jge 0x23fd
pushq $0x3
popq %r9
subl %ecx, %r9d
subl %ecx, %r9d
movq %r9, 0x8(%rsp)
testl %r8d, %r8d
movl %edx, 0x18(%rsp)
movq %rdi, %r15
movl %esi, %r12d
je 0x241e
xorl %r14d, %r14d
xorl %r13d, %r13d
movl %r14d, %eax
subl %ecx, %eax
jg 0x240c
movq %rax, 0x20(%rsp)
movq %rcx, 0x10(%rsp)
leal 0x1(%rcx), %ebp
movl %r14d, %ebx
cmpl %ebx, %ebp
je 0x23c2
movq %r15, %rdi
movl %r14d, %ecx
movl %ebx, %r8d
movl 0x1c(%rsp), %r9d
callq 0x2497
movl %r12d, %esi
movl 0x18(%rsp), %edx
negl %eax
movl $0x0, %eax
sbbl %eax, %eax
orl %eax, %r13d
incl %ebx
jmp 0x2394
movq 0x8(%rsp), %rax
testl %eax, %eax
js 0x23e4
movq 0x20(%rsp), %rcx
leal (%rax,%rcx,4), %eax
addl $0xa, %eax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
decl %ecx
jmp 0x23f5
leal (%rax,%r14,4), %eax
addl $0x6, %eax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
incl %r14d
jmp 0x2379
callq 0x1060
movl $0x22, (%rax)
pushq $-0x1
popq %r13
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, 0x10(%rsp)
xorl %ecx, %ecx
pushq $0x6
popq %r8
xorl %r13d, %r13d
movq 0x8(%rsp), %r14
movl %ecx, %ebp
movq 0x10(%rsp), %rbx
subl %ebx, %ebp
jg 0x240c
movl %r8d, 0x20(%rsp)
movl %ecx, 0x8(%rsp)
movl %ebx, %r8d
movl 0x1c(%rsp), %r9d
callq 0x2497
negl %eax
movl $0x0, %eax
sbbl %eax, %eax
testl %r14d, %r14d
js 0x2476
leal (%r14,%rbp,4), %r14d
addl $0xa, %r14d
decl %ebx
movq %rbx, 0x10(%rsp)
movl 0x20(%rsp), %r8d
jmp 0x247e
movl 0x20(%rsp), %r8d
addl %r8d, %r14d
orl %eax, %r13d
movl 0x8(%rsp), %ecx
incl %ecx
addl $0x4, %r8d
movl 0x18(%rsp), %edx
movq %r15, %rdi
movl %r12d, %esi
jmp 0x2431
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebx
movq %r8, 0x20(%rsp)
movl %ecx, %r14d
movq %rdx, 0x28(%rsp)
movq %rdi, %r12
leal (%r14,%rsi), %eax
movl %eax, 0x4(%rsp)
movq %rsi, %r15
movq %rsi, 0x8(%rsp)
movq %r14, 0x30(%rsp)
leal (%r8,%rdx), %ebp
movl %eax, %esi
movl %ebp, %edx
movl %r9d, %ecx
callq 0x2190
movl %eax, 0x1c(%rsp)
movl %r15d, %r13d
subl %r14d, %r13d
movq %r12, %rdi
movl %r13d, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x2190
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %r14
movl %r14d, %ebp
movq 0x20(%rsp), %r15
subl %r15d, %ebp
movq %r12, %rdi
movl 0x4(%rsp), %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x2190
movl %eax, 0x4(%rsp)
movq %r12, %rdi
movl %r13d, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x2190
movl %eax, %r13d
movq 0x8(%rsp), %rax
leal (%r15,%rax), %esi
movl %esi, 0x10(%rsp)
movq 0x30(%rsp), %r15
leal (%r15,%r14), %ebp
movq %r12, %rdi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x2190
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rsi
subl 0x20(%rsp), %esi
movq %rsi, 0x8(%rsp)
movq %r12, %rdi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x2190
movl %eax, %ebp
subl %r15d, %r14d
movq %r12, %rdi
movl 0x10(%rsp), %esi
movl %r14d, %edx
movl %ebx, %ecx
callq 0x2190
movl %eax, %r15d
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movl %r14d, %edx
movl %ebx, %ecx
callq 0x2190
orl %r15d, %eax
orl 0x14(%rsp), %ebp
orl %eax, %ebp
orl 0x4(%rsp), %r13d
orl 0x18(%rsp), %r13d
orl %ebp, %r13d
xorl %eax, %eax
orl 0x1c(%rsp), %r13d
setne %al
negl %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0xc(%rsp)
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %ebx
movq %rdi, %r13
movl 0x50(%rsp), %r15d
testl %r9d, %r9d
movl %esi, 0x10(%rsp)
je 0x2631
xorl %r12d, %r12d
cmpl 0xc(%rsp), %r14d
jl 0x2624
jmp 0x26a3
movq %r13, %rdi
movl %ebx, %esi
movl %r14d, %edx
movl %r15d, %ecx
callq 0x2190
negl %eax
movl $0x0, %eax
sbbl %eax, %eax
orl %eax, %r12d
incl %ebx
cmpl %ebp, %ebx
jle 0x2606
incl %r14d
movl 0x10(%rsp), %ebx
jmp 0x25fa
xorl %r12d, %r12d
cmpl %ebp, %ebx
jg 0x2698
movq %r13, %rdi
movl %ebx, %esi
movl %r14d, %edx
movl %r15d, %ecx
callq 0x2190
movl %eax, 0x14(%rsp)
movq %r13, %rdi
movl %ebx, %esi
movl 0xc(%rsp), %edx
movl %r15d, %ecx
callq 0x2190
orl 0x14(%rsp), %eax
pushq $-0x1
popq %rax
cmovnel %eax, %r12d
incl %ebx
jmp 0x2634
movq %r13, %rdi
movl %r14d, %edx
movl %r15d, %ecx
callq 0x2190
movl %eax, %ebx
movq %r13, %rdi
movl %ebp, %esi
movl %r14d, %edx
movl %r15d, %ecx
callq 0x2190
orl %ebx, %eax
pushq $-0x1
popq %rax
cmovnel %eax, %r12d
incl %r14d
cmpl 0xc(%rsp), %r14d
movl 0x10(%rsp), %esi
jl 0x266c
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0x4(%rsp)
movq %rcx, 0x8(%rsp)
movl %edx, %r15d
movq %rdi, %r12
shll $0x4, %esi
movslq %esi, %rbx
addq (%r9), %rbx
xorl %ecx, %ecx
xorl %ebp, %ebp
cmpl $0x10, %ecx
je 0x2737
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
leal (%rcx,%rax), %r13d
xorl %r14d, %r14d
cmpl $0x8, %r14d
je 0x272b
movzbl (%rbx), %eax
movl %r14d, %ecx
shll %cl, %eax
testb %al, %al
jns 0x2726
leal (%r15,%r14), %esi
movq %r12, %rdi
movl %r13d, %edx
movl 0x4(%rsp), %ecx
callq 0x2190
negl %eax
movl $0x0, %eax
sbbl %eax, %eax
orl %eax, %ebp
incl %r14d
jmp 0x26f6
movq 0x10(%rsp), %rcx
incl %ecx
incq %rbx
jmp 0x26e0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
xorl %r13d, %r13d
movsbl (%r12), %esi
testl %esi, %esi
je 0x279c
movq %rbx, %rdi
movl %r15d, %edx
movl %r14d, %ecx
movl %ebp, %r8d
movq (%rsp), %r9
callq 0x26b5
negl %eax
movl $0x0, %eax
sbbl %eax, %eax
orl %eax, %r13d
addl $0x8, %r15d
incq %r12
jmp 0x2769
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movq %rsi, %rcx
leaq 0x4(%rsp), %rax
movb %dil, (%rax)
movb $0x0, 0x1(%rax)
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %rax, %rdi
callq 0x1180
xorl %ecx, %ecx
cmpl $0x2, %eax
setne %cl
negl %ecx
movl %ecx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x164a(%rip), %rsi      # 0x400c
movq %rax, %rdi
callq 0x1160
testq %rax, %rax
je 0x29eb
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x27ae
movl %eax, %ebx
movq %r14, %rdi
callq 0x1090
movl %ebx, %eax
jmp 0x29ee
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
testq %r14, %r14
jne 0x2a2d
movq 0x18(%rsi), %r14
testq %r14, %r14
je 0x2a68
movl 0x38(%rsi), %eax
decl %eax
movl %eax, %ebp
subl 0x38(%r14), %ebp
jle 0x2a68
movl %eax, 0x38(%r14)
movslq 0x3c(%r14), %r15
shlq $0x4, %r15
addq 0x20(%rbx), %r15
movq 0x28(%r14), %r14
cmpq %r15, %r14
je 0x2a68
addl %ebp, 0x10(%r14)
addq $-0x28, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a11
jmp 0x2a4a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edi, %ebx
testl %edi, %edi
js 0x338f
pushq $0x1
popq %rdi
pushq $0x40
popq %rsi
callq 0x10d0
testq %rax, %rax
je 0x3398
movl %ebx, %ecx
movq %rcx, (%rax)
leaq 0x3d66(%rip), %rdi      # 0x70e0
movq %rax, %rsi
callq 0x129c
testl %eax, %eax
je 0x33a9
leaq 0xd67(%rip), %rdi       # 0x40f4
jmp 0x339f
leaq 0xd0d(%rip), %rdi       # 0x40a3
jmp 0x339f
leaq 0xd30(%rip), %rdi       # 0x40cf
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
jmp 0x10b0
leaq 0xd38(%rip), %rdi       # 0x40e8
movl %ebx, %esi
xorl %eax, %eax
callq 0x10b0
incl 0x3dd1(%rip)            # 0x7190
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %edi, %ebp
movl %edi, %esi
leaq 0x3d11(%rip), %rdi      # 0x70e0
callq 0x13ff
testq %rax, %rax
je 0x3410
movq %rax, %rbx
leaq 0x3cfd(%rip), %rdi      # 0x70e0
movq %rax, %rsi
callq 0x143c
movl (%rbx), %esi
leaq 0xd28(%rip), %rdi       # 0x411c
xorl %eax, %eax
callq 0x10b0
movq %rbx, %rdi
callq 0x1030
decl 0x3d87(%rip)            # 0x7190
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xcf6(%rip), %rdi       # 0x410d
movl %ebp, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edi, %ebx
movl %edi, %esi
leaq 0x3cae(%rip), %rdi      # 0x70e0
callq 0x13ff
testq %rax, %rax
je 0x3445
movq %rax, %rsi
popq %rbx
jmp 0x3812
leaq 0xcc1(%rip), %rdi       # 0x410d
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1351(%rip), %rdi      # 0x47b4
callq 0x1070
testq %rbx, %rbx
je 0x34c6
leaq 0xbcd(%rip), %rdi       # 0x4041
movq %rbx, %rsi
callq 0x10e0
testl %eax, %eax
je 0x34dd
movzbl (%rbx), %ebp
movl %ebp, %eax
subl $0x69, %eax
jne 0x3497
movzbl 0x1(%rbx), %eax
subl $0x6e, %eax
jne 0x3497
movzbl 0x2(%rbx), %eax
negl %eax
testl %eax, %eax
je 0x34f4
leaq 0xba1(%rip), %rdi       # 0x4045
movq %rbx, %rsi
callq 0x10e0
testl %eax, %eax
je 0x350b
testb %bpl, %bpl
je 0x34c6
leaq 0xca2(%rip), %rdi       # 0x415e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10b0
leaq 0x3c13(%rip), %rdi      # 0x70e0
leaq 0x33e(%rip), %rsi       # 0x3812
xorl %edx, %edx
callq 0x17f7
jmp 0x3520
leaq 0x3bfc(%rip), %rdi      # 0x70e0
leaq 0x327(%rip), %rsi       # 0x3812
xorl %edx, %edx
callq 0x16cd
jmp 0x3520
leaq 0x3be5(%rip), %rdi      # 0x70e0
leaq 0x310(%rip), %rsi       # 0x3812
xorl %edx, %edx
callq 0x172b
jmp 0x3520
leaq 0x3bce(%rip), %rdi      # 0x70e0
leaq 0x2f9(%rip), %rsi       # 0x3812
xorl %edx, %edx
callq 0x1789
movl 0x3c6a(%rip), %esi      # 0x7190
leaq 0xd0a(%rip), %rdi       # 0x4237
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rdi, %rbx
leaq 0xc44(%rip), %rdi       # 0x4199
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10b0
leaq 0xa9e(%rip), %rsi       # 0x4004
movq %rbx, %rdi
callq 0x1160
movq %rax, (%rsp)
testq %rax, %rax
je 0x3638
movq %rbx, 0x8(%rsp)
pushq $-0x1
popq %rbp
leaq 0x10(%rsp), %rbx
pushq $0x1
popq %r15
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
movq %r15, %rsi
movq (%rsp), %rcx
callq 0x1080
movq %rax, %r13
testl %r13d, %r13d
jle 0x365a
movq %rbx, %r14
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x3606
movsbq 0x10(%rsp,%r12), %rbx
callq 0x1190
movq (%rax), %rax
movzwl (%rax,%rbx,2), %eax
btl $0xd, %eax
jb 0x35ec
btl $0xb, %eax
jae 0x360b
cmpl $-0x1, %ebp
je 0x35fc
imull $0xa, %ebp, %eax
leal (%rax,%rbx), %ebp
addl $-0x30, %ebp
jmp 0x3601
testl %ebp, %ebp
js 0x3601
movl %ebp, %edi
callq 0x3357
pushq $-0x1
popq %rbp
jmp 0x3601
addl $-0x30, %ebx
movl %ebx, %ebp
incq %r12
jmp 0x35b9
movq %r14, %rbx
jmp 0x358c
leaq 0xbb5(%rip), %rdi       # 0x41c7
movq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x10b0
movq (%rsp), %rdi
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1090
leaq 0xb6f(%rip), %rdi       # 0x41ae
movq %rbx, %rsi
xorl %eax, %eax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
testl %ebp, %ebp
js 0x3665
movl %ebp, %edi
callq 0x3357
movq (%rsp), %rdi
callq 0x1090
movl 0x3b1c(%rip), %esi      # 0x7190
leaq 0xbbc(%rip), %rdi       # 0x4237
xorl %eax, %eax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
andq $0x0, 0x10(%rsp)
leaq 0xb36(%rip), %rdi       # 0x41e0
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10b0
leaq 0x951(%rip), %rsi       # 0x400c
movq %rbx, %rdi
callq 0x1160
testq %rax, %rax
je 0x3723
movq %rax, %r14
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
andl $0x0, 0x8(%rdx)
leaq 0x3a02(%rip), %rdi      # 0x70e0
leaq 0x20c(%rip), %rsi       # 0x38f1
callq 0x172b
testl %eax, %eax
je 0x36ff
leaq 0xafd(%rip), %rdi       # 0x41f2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10b0
movq %r14, %rdi
callq 0x1090
movl 0x3a83(%rip), %esi      # 0x7190
leaq 0xb23(%rip), %rdi       # 0x4237
xorl %eax, %eax
callq 0x10b0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0xa84(%rip), %rdi       # 0x41ae
movq %rbx, %rsi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0xcbe(%rip), %rdi       # 0x4409
callq 0x1070
leaq 0x3989(%rip), %rdi      # 0x70e0
leaq 0x3a22(%rip), %rsi      # 0x7180
movl %ebx, %edx
callq 0x1b09
testq %rax, %rax
je 0x37ce
movq %rax, %rbx
testq %r14, %r14
je 0x37a7
cmpb $0x0, (%r14)
je 0x37a7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29b1
testl %eax, %eax
je 0x37e9
movq %rbx, %rdi
callq 0x2181
leaq 0xa78(%rip), %rdi       # 0x420e
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10b0
movq 0x382a(%rip), %rax      # 0x6fd8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x27ae
testl %eax, %eax
je 0x37e1
movq %rbx, %rdi
callq 0x2181
leaq 0xc50(%rip), %rdi       # 0x441c
jmp 0x37d5
leaq 0xc6b(%rip), %rdi       # 0x4440
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1070
pushq $0xa
popq %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x2181
movl 0x3999(%rip), %esi      # 0x7190
leaq 0xa33(%rip), %rdi       # 0x4231
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movq 0x20(%rsi), %rdi
testq %rdi, %rdi
je 0x3861
movl (%rdi), %eax
cmpl $0x1, 0x8(%rsi)
leaq 0x80e(%rip), %r9        # 0x4037
leaq 0x7d5(%rip), %rcx       # 0x4005
cmoveq %r9, %rcx
movl (%rsi), %edx
cmpq %rsi, 0x18(%rdi)
leaq 0x817(%rip), %r8        # 0x4058
cmoveq %r9, %r8
movl 0x38(%rsi), %r9d
movl 0x3c(%rsi), %esi
movl %esi, (%rsp)
leaq 0x8ef(%rip), %rdi       # 0x4145
movl %eax, %esi
xorl %eax, %eax
callq 0x10b0
jmp 0x3890
movl (%rsi), %eax
cmpl $0x1, 0x8(%rsi)
leaq 0x7c9(%rip), %rcx       # 0x4037
leaq 0x790(%rip), %rdx       # 0x4005
cmoveq %rcx, %rdx
movl 0x38(%rsi), %ecx
movl 0x3c(%rsi), %r8d
leaq 0x8a0(%rip), %rdi       # 0x4127
movl %eax, %esi
xorl %eax, %eax
callq 0x10b0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
leaq 0xbbd(%rip), %rdi       # 0x4459
callq 0x1070
leaq 0x3838(%rip), %rdi      # 0x70e0
leaq 0x35(%rip), %rsi        # 0x38e4
xorl %edx, %edx
callq 0x1789
andq $0x0, 0x3822(%rip)      # 0x70e0
leaq -0xb9(%rip), %rax       # 0x380c
movq %rax, 0x381c(%rip)      # 0x70e8
andl $0x0, 0x38bd(%rip)      # 0x7190
leaq 0x95d(%rip), %rdi       # 0x4237
xorl %esi, %esi
xorl %eax, %eax
popq %rcx
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]rbtree/test/test.c
// Function: save_node
static int save_node(rbtree_t *tree, rbnode_t *n, void *state)
{
	struct save_state *ss = state;
	char *key;
	int r;

	if (ss->i > 0) {
		if ((ss->i % 8) == 0) {
			if (fwrite("\n", 1, 1, ss->pf) != 1)
				return -1;
		}
		else {
			if (fwrite("\t", 1, 1, ss->pf) != 1)
				return -1;
		}
	}

    key = keytostr(n->key);

	r = strlen(key);

	if (fwrite(key, 1, r, ss->pf) != r)
		return -1;

	ss->i++;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movl 0x8(%rdx), %eax
pushq $-0x1
popq %rbx
testl %eax, %eax
jle 0x3931
movq (%r14), %rcx
testb $0x7, %al
je 0x3919
leaq 0x8f5(%rip), %rdi       # 0x420c
jmp 0x3920
leaq 0x88c(%rip), %rdi       # 0x41ac
pushq $0x1
popq %rdx
movq %rdx, %rsi
callq 0x1180
cmpq $0x1, %rax
jne 0x3978
movl (%r15), %ecx
leaq 0x3865(%rip), %r15      # 0x71a0
leaq 0x6d1(%rip), %rdx       # 0x4013
movl $0x80, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10c0
movq %r15, %rdi
callq 0x10a0
movslq %eax, %r12
movq (%r14), %rcx
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x1180
cmpq %r12, %rax
jne 0x3978
incl 0x8(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]rbtree/test/test.c
// Function: next_arg
static int next_arg(char *buf, int bufsize)
{
	int i, ch;
	skip_blank();
	for (i = 0, ch = getchar();
		ch != '\n' && ch != EOF && i < bufsize;
		i++, ch = getchar()) {
		if (isblank(ch))
			break;
		buf[i] = (char)ch;
	}
	if (i < bufsize)
		buf[i] = '\0';
	if (i > 0) {
		if (ch == '\n' || ch == EOF)
			ungetc('\n', stdin);
	}
	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x10f0
movl %eax, %r14d
cmpl $-0x1, %eax
je 0x39c6
cmpl $0xa, %r14d
je 0x39c6
callq 0x1190
movq (%rax), %rax
movslq %r14d, %rcx
testb $0x1, (%rax,%rcx,2)
jne 0x39a2
cmpl $-0x1, %r14d
pushq $0xa
popq %rdi
cmovnel %r14d, %edi
movq 0x3608(%rip), %r12      # 0x6fe0
movq (%r12), %rsi
callq 0x1120
callq 0x10f0
movl %eax, %r15d
xorl %r13d, %r13d
testl %ebp, %ebp
movl $0x0, %r14d
cmovgl %ebp, %r14d
cmpl $-0x1, %r15d
je 0x3a2b
cmpl $0xa, %r15d
je 0x3a2b
cmpq %r13, %r14
je 0x3a38
callq 0x1190
movq (%rax), %rax
movslq %r15d, %rcx
testb $0x1, (%rax,%rcx,2)
jne 0x3a2b
movb %r15b, (%rbx,%r13)
incq %r13
callq 0x10f0
movl %eax, %r15d
jmp 0x39f8
cmpl %ebp, %r13d
jge 0x3a35
movb $0x0, (%rbx,%r13)
movl %r13d, %r14d
testl %r14d, %r14d
je 0x3a55
cmpl $0xa, %r15d
je 0x3a49
cmpl $-0x1, %r15d
jne 0x3a55
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x1120
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]rbtree/test/test.c
// Function: read_values
static int read_values(array_t *arr)
{
	int r, v;
	while ((r = next_value(&v)) == 0) {
		if (arr->cap <= arr->entries) {
			int cap = arr->cap << 1, *p;
			if (cap == 0)
				cap = 8;
			p = realloc(arr->array, cap * sizeof(int));
			if (p == NULL)
				return -1;
			arr->cap = cap;
			arr->array = p;
		}
		arr->array[arr->entries++] = v;
	}
	if (r && errno == EOF)
		return 0;
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %r13d, %r13d
pushq $0xa
popq %rbp
xorl %r12d, %r12d
xorl %ebx, %ebx
movl %r13d, %eax
movl %eax, %r13d
callq 0x10f0
movl %eax, %r15d
cmpl $-0x1, %eax
je 0x3aff
cmpl $0xa, %r15d
je 0x3aff
callq 0x1190
movq (%rax), %rax
movslq %r15d, %rcx
movzwl (%rax,%rcx,2), %eax
testb $0x1, %al
je 0x3ab5
xorl %eax, %eax
testl %r13d, %r13d
je 0x3a83
jmp 0x3aff
cmpl $0x2d, %r15d
je 0x3ada
cmpl $0x2b, %r15d
je 0x3ada
btl $0xb, %eax
jae 0x3b86
imull $0xa, %ebx, %eax
leal (%rax,%r15), %ebx
addl $-0x30, %ebx
incl %r13d
jmp 0x3a80
testl %r12d, %r12d
jne 0x3b86
testl %r13d, %r13d
jg 0x3b86
xorl %eax, %eax
cmpl $0x2d, %r15d
setne %al
leal -0x1(,%rax,2), %r12d
jmp 0x3a80
testl %r13d, %r13d
jle 0x3b7a
movl %ebx, %r13d
negl %r13d
cmpl $-0x1, %r12d
cmovnel %ebx, %r13d
cmpl $0xa, %r15d
je 0x3b1e
cmpl $-0x1, %r15d
jne 0x3b2f
movq 0x34bb(%rip), %rax      # 0x6fe0
movq (%rax), %rsi
movl %ebp, %edi
callq 0x1120
movl (%r14), %ecx
movl 0x4(%r14), %ebx
movq 0x8(%r14), %rax
cmpl %ecx, %ebx
jg 0x3b65
addl %ebx, %ebx
pushq $0x8
popq %rcx
cmovel %ecx, %ebx
movslq %ebx, %rsi
shlq $0x2, %rsi
movq %rax, %rdi
callq 0x1150
testq %rax, %rax
je 0x3b81
movl %ebx, 0x4(%r14)
movq %rax, 0x8(%r14)
movl (%r14), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%r14)
movslq %ecx, %rcx
movl %r13d, (%rax,%rcx,4)
xorl %r13d, %r13d
jmp 0x3a7b
xorl %ebx, %ebx
pushq $-0x1
popq %rbp
jmp 0x3b91
pushq $-0x1
popq %rax
jmp 0x3b9a
callq 0x3ba9
pushq $0x16
popq %rbp
pushq $-0x1
popq %rbx
callq 0x1060
movl %ebp, (%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/veltzer[P]xmeltdown/src/stickman.c
// Function: HandleKeyPress
void HandleKeyPress(XKeyEvent* pevent)
{
	char charback;

	XLookupString(pevent, &charback, 1, NULL, NULL);
	switch (charback) {
	case 'q':
	case 'Q':
		exit(0);
	case ' ':
	case '\n':
		DumpSkel(&bones);
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xf(%rsp), %rbx
pushq $0x1
popq %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1050
movzbl (%rbx), %eax
cmpl $0xa, %eax
je 0x1429
cmpl $0x20, %eax
je 0x1429
cmpl $0x71, %eax
je 0x1422
cmpl $0x51, %eax
jne 0x1435
xorl %edi, %edi
callq 0x1060
leaq 0x2c98(%rip), %rdi      # 0x40c8
callq 0x1744
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/veltzer[P]xmeltdown/src/stickman.c
// Function: HandleButtonPress
void HandleButtonPress(XButtonEvent* pevent)
{
	targetray=FindNearestRay(pevent);
	switch (pevent->button) {
/*
** Button 1 rotates the selected segment about its anchor.
*/
	case 1:
		ButtonDown=1;
		FlashRay (targetray);
		break;
/*
** Button 2 drags the whole body around.
*/
	case 2:
		DrawSkel(&bones, set_gc, buffer[0]);
		DrawSkel(&bones, dotted_gc, buffer[0]);
		ButtonDown=2;
		offsetx=bones.waistx-pevent->x;
		offsety=bones.waisty-pevent->y;
		break;
/*
** Button 3 prints the current variables to the screen.
*/

	case 3:
		ButtonDown=3;
		FlashRay (targetray);
		break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x16e8
movq %rax, 0x2e19(%rip)      # 0x4268
movl 0x54(%rbx), %ecx
cmpl $0x3, %ecx
je 0x14cd
cmpl $0x2, %ecx
je 0x146d
cmpl $0x1, %ecx
jne 0x14c7
movl $0x1, 0x2df5(%rip)      # 0x4260
jmp 0x14d7
movq 0x2dd4(%rip), %rsi      # 0x4248
leaq 0x2e85(%rip), %r15      # 0x4300
movq (%r15), %rdx
leaq 0x2c43(%rip), %r14      # 0x40c8
movq %r14, %rdi
callq 0x17a6
movq 0x2dbc(%rip), %rsi      # 0x4250
movq (%r15), %rdx
movq %r14, %rdi
callq 0x17a6
movl $0x2, 0x2db7(%rip)      # 0x4260
movl 0x2c1d(%rip), %eax      # 0x40cc
subl 0x40(%rbx), %eax
movl %eax, 0x2db8(%rip)      # 0x4270
movl 0x2c12(%rip), %eax      # 0x40d0
subl 0x44(%rbx), %eax
movl %eax, 0x2dad(%rip)      # 0x4274
popq %rbx
popq %r14
popq %r15
retq
movl $0x3, 0x2d89(%rip)      # 0x4260
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1695
// File: /workspace/github_c_makefile_star2_O2/veltzer[P]xmeltdown/src/stickman.c
// Function: FlashRay
void FlashRay(RayPtr targetray)
{
/*
 *	XDrawLine(	dpy, buffer[0], set_gc,
 * targetray->x, targetray->y,
 * targetray->anchor->x, targetray->anchor->y);
 */

	XDrawLine(dpy, buffer[0], dotted_gc,
		targetray->x, targetray->y,
		targetray->anchor->x, targetray->anchor->y);
}

// Assembly:
pushq %rax
leaq 0x2c43(%rip), %rax      # 0x42e0
movq (%rax), %rax
leaq 0x2c59(%rip), %rcx      # 0x4300
movq (%rcx), %rsi
movq 0x2b9f(%rip), %rdx      # 0x4250
movl 0x10(%rdi), %ecx
movl 0x14(%rdi), %r8d
movq 0x18(%rdi), %rdi
movl 0x10(%rdi), %r9d
movl 0x14(%rdi), %edi
movl %edi, (%rsp)
movq %rax, %rdi
callq 0x10d0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/veltzer[P]xmeltdown/src/stickman.c
// Function: FindNearestRay
RayPtr FindNearestRay(XButtonEvent* pevent) {
	RayPtr retval=NULL;
	double olddist, newdist;
	int x, y;
	RayPtr stepray;
	int stepsize=sizeof(Ray);

	x=pevent->x;
	y=pevent->y;

	olddist=99999;
/*
** Yes, I KNOW the following is a disgusting way to step through all the
** ray elements of the "bones" data structure. So there! Neah neah neah.
*/
	for (stepray=&(bones.torso); stepray <= &(bones.ltricep); stepray=(RayPtr) ((long) stepray+(long) stepsize)) {
		newdist=(FindDistance(x, y, stepray));
		if (newdist < olddist) {
			retval=stepray;
			olddist=newdist;
		}
	}
	return (retval);
}

// Assembly:
movl 0x40(%rdi), %ecx
movl 0x44(%rdi), %edx
leaq 0x29e3(%rip), %rsi      # 0x40d8
movsd 0x913(%rip), %xmm0      # 0x2010
xorl %eax, %eax
leaq 0x2b12(%rip), %rdi      # 0x4218
cmpq %rdi, %rsi
ja 0x1743
movl %ecx, %r8d
subl 0x10(%rsi), %r8d
movl %edx, %r9d
subl 0x14(%rsi), %r9d
imull %r8d, %r8d
imull %r9d, %r9d
addl %r8d, %r9d
cvtsi2sd %r9, %xmm1
sqrtsd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
cmovaq %rsi, %rax
minsd %xmm0, %xmm1
addq $0x20, %rsi
movapd %xmm1, %xmm0
jmp 0x1706
retq
// File: /workspace/github_c_makefile_star2_O2/CSerxzm[P]WindowstoLinuxInterface/src/COMP.c
// Function: main
int main(int argc, char **argv)
{
	char lines[argc+1][255];
    predealLine(argc, argv, lines);
    char* filename1 = lines[1];
    char* filename2 = lines[2];
    int flag = comp(filename1, filename2);
	if(!flag) {
		printf("文件的大小不同\n");
	}
	else {
		printf("文件比较无误\n");
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leal 0x1(%rdi), %eax
movq %rsp, %r14
imulq $0xff, %rax, %r15
addq $0xf, %r15
andq $-0x10, %r15
movq %r14, %rbx
subq %r15, %rbx
movq %rbx, %rsp
movq %rbx, %rdx
callq 0x11bc
addq $0xff, %rbx
negq %r15
leaq (%r14,%r15), %rsi
addq $0x1fe, %rsi            # imm = 0x1FE
movq %rbx, %rdi
callq 0x1307
testl %eax, %eax
leaq 0xd42(%rip), %rax       # 0x202c
leaq 0xd51(%rip), %rdi       # 0x2042
cmoveq %rax, %rdi
callq 0x1030
xorl %eax, %eax
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/CSerxzm[P]WindowstoLinuxInterface/src/COMP.c
// Function: comp
int comp(char* filename1, char*filename2) 
{
	FILE *file1;
	FILE *file2;
	char ch1, ch2;
	int flag = 1;
	if((file1=fopen(filename1, "r"))==NULL) {
    		printf("文件不能打开");
    		exit(0);
	}
	if((file2=fopen(filename2, "r"))==NULL) {
    		printf("文件不能打开");
    		exit(0);
	}
	printf("比较 %s 和 %s \n", filename1, filename2);
	while((ch1 = fgetc(file1)) != EOF && (ch2 = fgetc(file2)) != EOF) {
    	if(ch1 == ch2)
    		continue;
    	else {
    		flag = 0;
    		break;
    	}
	}
	if( ((ch1 = fgetc(file1)) != EOF && (ch2 = fgetc(file2)) == EOF) || 
	    ((ch1 = fgetc(file1)) == EOF && (ch2 = fgetc(file2)) != EOF) ) {
		flag = 0;
	}
	fclose(file1);
	fclose(file2);
	return flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0xce5(%rip), %rsi       # 0x2004
callq 0x1080
testq %rax, %rax
je 0x13e4
movq %rax, %rbx
leaq 0xccd(%rip), %rsi       # 0x2004
movq %r15, %rdi
callq 0x1080
testq %rax, %rax
je 0x13e4
movq %rax, %r14
leaq 0xcc7(%rip), %rdi       # 0x2019
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1060
pushq $0x1
popq %r15
movq %rbx, %rdi
callq 0x1070
movl %eax, %r12d
shll $0x18, %r12d
cmpl $0xff000000, %r12d      # imm = 0xFF000000
je 0x1395
movq %r14, %rdi
callq 0x1070
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0x1395
cmpl %eax, %r12d
je 0x1363
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x1070
cmpb $-0x1, %al
je 0x13ad
movq %r14, %rdi
callq 0x1070
cmpb $-0x1, %al
je 0x13c5
movq %rbx, %rdi
callq 0x1070
cmpb $-0x1, %al
jne 0x13c8
movq %r14, %rdi
callq 0x1070
cmpb $-0x1, %al
je 0x13c8
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1040
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc1b(%rip), %rdi       # 0x2006
xorl %eax, %eax
callq 0x1060
xorl %edi, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: addsym
static void
addsym(bool ignorethis, bool definethis, char *sym)
{
	int symind;
	char *val;

	symind = findsym(sym);
	if (symind < 0) {
		if (nsyms >= MAXSYMS)
			errx(2, "too many symbols");
		symind = nsyms++;
	}
	symname[symind] = sym;
	ignore[symind] = ignorethis;
	val = sym + (skipsym(sym) - sym);
	if (definethis) {
		if (*val == '=') {
			value[symind] = val+1;
			*val = '\0';
		} else if (*val == '\0')
			value[symind] = "1";
		else
			usage();
	} else {
		if (*val != '\0')
			usage();
		value[symind] = NULL;
	}
	debug("addsym %s=%s", symname[symind],
	    value[symind] ? value[symind] : "undef");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
movq %rdx, %rdi
callq 0x4162
testl %eax, %eax
jns 0x3779
movl 0xfceb(%rip), %eax      # 0x13450
cmpl $0x1000, %eax           # imm = 0x1000
jge 0x3815
leal 0x1(%rax), %ecx
movl %ecx, 0xfcd7(%rip)      # 0x13450
movslq %eax, %r15
leaq 0xfcdd(%rip), %rax      # 0x13460
movq %rbx, (%rax,%r15,8)
leaq 0xeb72(%rip), %rax      # 0x12300
movb %r14b, (%r15,%rax)
movq %rbx, %rdi
callq 0x40f9
movzbl (%rax), %ecx
testb %bpl, %bpl
je 0x37c1
testl %ecx, %ecx
je 0x37d5
cmpl $0x3d, %ecx
jne 0x3810
movq %rax, %rcx
incq %rcx
leaq 0x6b48(%rip), %rdx      # 0xa300
movq %rcx, (%rdx,%r15,8)
movb $0x0, (%rax)
jmp 0x37e7
testl %ecx, %ecx
jne 0x3810
leaq 0x6b34(%rip), %rax      # 0xa300
andq $0x0, (%rax,%r15,8)
xorl %ecx, %ecx
jmp 0x37e7
leaq 0x6b24(%rip), %rax      # 0xa300
leaq 0x1f1c(%rip), %rcx      # 0x56ff
movq %rcx, (%rax,%r15,8)
testq %rcx, %rcx
leaq 0x1f1d(%rip), %rdx      # 0x570e
cmovneq %rcx, %rdx
leaq 0x1f05(%rip), %rdi      # 0x5701
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3caf
callq 0x3826
leaq 0x1ed2(%rip), %rsi      # 0x56ee
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: error
static void
error(const char *msg)
{
	if (depth == 0)
		warnx("%s: %d: %s", filename, linenum, msg);
	else
		warnx("%s: %d: %s (#if line %d depth %d)",
		    filename, linenum, msg, stifline[depth], depth);
	closeout();
	errx(2, "output may be truncated");
}

// Assembly:
pushq %rax
movq %rdi, %rcx
movslq 0x5570(%rip), %r9       # 0x92c0
movq 0x4431(%rip), %rsi      # 0x8188
movl 0x5567(%rip), %edx      # 0x92c4
testq %r9, %r9
jne 0x3d72
leaq 0x15fd(%rip), %rdi      # 0x5366
xorl %eax, %eax
callq 0x3100
jmp 0x3d8b
leaq 0xf587(%rip), %rax      # 0x13300
movl (%rax,%r9,4), %r8d
leaq 0x15ed(%rip), %rdi      # 0x5371
xorl %eax, %eax
callq 0x3100
callq 0x4342
leaq 0x15fc(%rip), %rsi      # 0x5393
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: strlcmp
static int
strlcmp(const char *s, const char *t, size_t n)
{
	while (n-- && *t != '\0')
		if (*s != *t)
			return ((unsigned char)*s - (unsigned char)*t);
		else
			++s, ++t;
	return ((unsigned char)*s);
}

// Assembly:
leaq (%rdi,%rdx), %rcx
xorl %r8d, %r8d
cmpq %r8, %rdx
je 0x415a
movzbl (%rsi,%r8), %r9d
testl %r9d, %r9d
je 0x4154
movzbl (%rdi,%r8), %eax
cmpb %r9b, %al
jne 0x415e
incq %r8
jmp 0x4136
addq %r8, %rdi
movq %rdi, %rcx
movzbl (%rcx), %eax
retq
subl %r9d, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: findsym
static int
findsym(const char *str)
{
	const char *cp;
	int symind;

	cp = skipsym(str);
	if (cp == str)
		return (-1);
	if (symlist) {
		if (symdepth && firstsym)
			printf("%s%3d", zerosyms ? "" : "\n", depth);
		firstsym = zerosyms = false;
		printf("%s%.*s%s",
		    symdepth ? " " : "",
		    (int)(cp-str), str,
		    symdepth ? "" : "\n");
		/* we don't care about the value of the symbol */
		return (0);
	}
	for (symind = 0; symind < nsyms; ++symind) {
		if (strlcmp(symname[symind], str, cp-str) == 0) {
			debug("findsym %s %s", symname[symind],
			    value[symind] ? value[symind] : "");
			return (symind);
		}
	}
	return (-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x40f9
movq %rax, %r14
pushq $-0x1
popq %rax
subq %rbx, %r14
je 0x4247
cmpb $0x0, 0x3ff5(%rip)      # 0x8180
je 0x4201
cmpb $0x1, 0x3fed(%rip)      # 0x8181
jne 0x424c
cmpb $0x1, 0x614f(%rip)      # 0xa2f0
jne 0x4289
leaq 0x1056(%rip), %r12      # 0x5204
leaq 0x1241(%rip), %r15      # 0x53f6
cmpb $0x0, 0xf244(%rip)      # 0x13400
movq %r15, %rsi
cmovneq %r12, %rsi
movl 0x50f7(%rip), %edx      # 0x92c0
leaq 0x1287(%rip), %rdi      # 0x5457
xorl %eax, %eax
callq 0x30f0
movb 0x3fa4(%rip), %al       # 0x8181
movb $0x1, 0xf21c(%rip)      # 0x13400
movb $0x0, 0x6105(%rip)      # 0xa2f0
leaq 0x1274(%rip), %rsi      # 0x5466
testb $0x1, %al
cmoveq %r15, %rsi
cmovneq %r15, %r12
jmp 0x42a5
movl 0xf248(%rip), %r13d     # 0x13450
xorl %r15d, %r15d
testl %r13d, %r13d
cmovlel %r15d, %r13d
shlq $0x3, %r13
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x4244
leaq 0xf23c(%rip), %rax      # 0x13460
movq (%rbp,%rax), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x412f
testl %eax, %eax
je 0x425c
addq $0x8, %rbp
incl %r15d
jmp 0x4218
pushq $-0x1
popq %rax
movl %eax, %r15d
jmp 0x42bf
leaq 0xfb1(%rip), %r12       # 0x5204
leaq 0x119c(%rip), %rsi      # 0x53f6
jmp 0x4297
leaq 0x609d(%rip), %rax      # 0xa300
movq (%rbp,%rax), %rax
testq %rax, %rax
leaq 0x1184(%rip), %rdx      # 0x53f6
cmovneq %rax, %rdx
leaq 0x11eb(%rip), %rdi      # 0x5468
movq %r12, %rsi
xorl %eax, %eax
callq 0x3caf
jmp 0x42bf
leaq 0x1166(%rip), %r12      # 0x53f6
leaq 0x11cf(%rip), %rsi      # 0x5466
movb $0x1, 0xf162(%rip)      # 0x13400
movb $0x0, 0x604b(%rip)      # 0xa2f0
leaq 0x11b1(%rip), %rdi      # 0x545d
xorl %r15d, %r15d
movl %r14d, %edx
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x30f0
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: ifeval
static Linetype
ifeval(const char **cpp)
{
	int ret;
	int val = 0;

	debug("eval %s", *cpp);
	constexpr = killconsts ? false : true;
	ret = eval_table(eval_ops, &val, cpp);
	debug("eval = %d", val);
	return (constexpr ? LT_IF : ret == LT_ERROR ? LT_IF : ret);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
andl $0x0, (%r14)
movq (%rdi), %rsi
leaq 0x118b(%rip), %rdi      # 0x5476
xorl %eax, %eax
callq 0x3caf
movb 0x3e7e(%rip), %al       # 0x8176
xorb $0x1, %al
movb %al, 0x17160(%rip)      # 0x1b460
leaq 0x3969(%rip), %rdi      # 0x7c70
movq %r14, %rsi
movq %rbx, %rdx
callq 0x43d2
movl %eax, %ebx
movl (%r14), %esi
leaq 0x1160(%rip), %rdi      # 0x547e
xorl %eax, %eax
callq 0x3caf
cmpl $0x16, %ebx
pushq $0x2
popq %rax
cmovel %eax, %ebx
cmpb $0x0, 0x1712b(%rip)     # 0x1b460
cmovnel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: closeout
static void
closeout(void)
{
	if (symdepth && !zerosyms)
		printf("\n");
	if (ferror(output) || fclose(output) == EOF) {
		if (overwriting) {
			warn("couldn't write to temporary file");
			unlink(tempname);
			errx(2, "%s unchanged", ofilename);
		} else {
			err(2, "couldn't write to %s", ofilename);
		}
	}
}

// Assembly:
pushq %rbx
cmpb $0x1, 0x3e37(%rip)      # 0x8181
jne 0x435d
cmpb $0x1, 0xf0ad(%rip)      # 0x13400
jne 0x435d
pushq $0xa
popq %rdi
callq 0x3030
movq 0x3e34(%rip), %rbx      # 0x8198
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
jne 0x437f
movq %rbx, %rdi
callq 0x30b0
cmpl $-0x1, %eax
je 0x437f
popq %rbx
retq
cmpb $0x1, 0x3e1a(%rip)      # 0x81a0
jne 0x43ba
leaq 0x101c(%rip), %rdi      # 0x53ab
xorl %eax, %eax
callq 0x3090
leaq 0x3e13(%rip), %rdi      # 0x81b0
callq 0x3060
movq 0x3dcf(%rip), %rdx      # 0x8178
leaq 0x101c(%rip), %rsi      # 0x53cc
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x30e0
movq 0x3db7(%rip), %rdx      # 0x8178
leaq 0x1011(%rip), %rsi      # 0x53d9
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x31c0