LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: main
int main()
{
	int t = 1531289551;
	//int t = time(NULL);
	printf("seed: %d\n", t);
	srand(t);
	oil_global_init();
	test_scale_all();
	test_scale_catrom_extremes();
	printf("worst error: %Lf\n", worst);
	printf("All tests pass.\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x5b459fcf, -0x8(%rbp) # imm = 0x5B459FCF
movl -0x8(%rbp), %esi
leaq 0x20c0(%rip), %rdi      # 0x6180
xorl %eax, %eax
callq 0x1070
movl -0x8(%rbp), %edi
callq 0x10a0
callq 0x1210
callq 0x4110
callq 0x5860
fldt 0xd7ec(%rip)            # 0x118d0
movq %rsp, %rax
fstpt (%rax)
leaq 0x209a(%rip), %rdi      # 0x618a
xorl %eax, %eax
callq 0x1070
leaq 0x209e(%rip), %rdi      # 0x619c
movb $0x0, %al
callq 0x1070
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: test_scale_all
static void test_scale_all()
{
	test_scale_all_permutations(5, 1);
	test_scale_all_permutations(8, 1);
	test_scale_all_permutations(8, 3);
	test_scale_all_permutations(100, 1);
	test_scale_all_permutations(100, 99);
	test_scale_all_permutations(2, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x5, %edi
movl $0x1, %esi
callq 0x4170
movl $0x8, %edi
movl $0x1, %esi
callq 0x4170
movl $0x8, %edi
movl $0x3, %esi
callq 0x4170
movl $0x64, %edi
movl $0x1, %esi
callq 0x4170
movl $0x64, %edi
movl $0x63, %esi
callq 0x4170
movl $0x2, %edi
movl $0x1, %esi
callq 0x4170
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: test_scale_each_cs
static void test_scale_each_cs(long dim_a, long dim_b)
{
	test_scale_square_rand(dim_a, dim_b, OIL_CS_G);
	test_scale_square_rand(dim_a, dim_b, OIL_CS_GA);
	test_scale_square_rand(dim_a, dim_b, OIL_CS_RGB);
	test_scale_square_rand(dim_a, dim_b, OIL_CS_RGBA);
	test_scale_square_rand(dim_a, dim_b, OIL_CS_CMYK);
	test_scale_square_rand(dim_a, dim_b, OIL_CS_RGBX);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x4230
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0x4230
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3, %edx
callq 0x4230
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x104, %edx            # imm = 0x104
callq 0x4230
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x204, %edx            # imm = 0x204
callq 0x4230
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x4230
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: test_scale_square_rand
static void test_scale_square_rand(long in_dim, long out_dim,
	enum oil_colorspace cs)
{
	long i, in_row_stride;
	unsigned char **input_image;

	in_row_stride = OIL_CMP(cs) * in_dim;

	/* Allocate & populate input image */
	input_image = alloc_2d_uchar(in_row_stride, in_dim);
	for (i=0; i<in_dim; i++) {
		fill_rand8(input_image[i], in_row_stride);
	}
	test_scale(in_dim, in_dim, input_image, out_dim, out_dim, cs);
	free_2d_uchar(input_image, in_dim);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movl %eax, %eax
imulq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x42d0
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x429c
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rsi
callq 0x4340
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x426f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %r8
movl -0x14(%rbp), %r9d
callq 0x4390
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x44a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: alloc_2d_uchar
static unsigned char **alloc_2d_uchar(long width, long height)
{
	long i;
	unsigned char **rows;

	rows = malloc(height * sizeof(unsigned char*));
	for (i=0; i<height; i++) {
		rows[i] = malloc(width * sizeof(unsigned char));
	}
	return rows;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
shlq $0x3, %rdi
callq 0x10e0
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x432d
movq -0x8(%rbp), %rdi
shlq $0x0, %rdi
callq 0x10e0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x42f9
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: test_scale
static void test_scale(long in_width, long in_height,
	unsigned char **input_image, long out_width, long out_height,
	enum oil_colorspace cs)
{
	long i, out_row_stride;
	unsigned char **oil_output_image;
	long double **ref_output_image;

	out_row_stride = OIL_CMP(cs) * out_width;

	/* oil scaling */
	oil_output_image = alloc_2d_uchar(out_row_stride, out_height);
	do_oil_scale(input_image, in_width, in_height, oil_output_image,
		out_width, out_height, cs);

	/* reference scaling */
	ref_output_image = alloc_2d_ld(out_row_stride, out_height);
	ref_scale(input_image, in_width, in_height, ref_output_image, out_width,
		out_height, cs);

	/* compare the two */
	for (i=0; i<out_height; i++) {
		validate_scanline8(oil_output_image[i], ref_output_image[i],
			out_width, OIL_CMP(cs));
	}

	free_2d_uchar(oil_output_image, out_height);
	free_2d_ld(ref_output_image, out_height);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movl %eax, %eax
imulq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x42d0
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movl -0x2c(%rbp), %eax
movl %eax, (%rsp)
callq 0x44f0
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x45f0
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movl -0x2c(%rbp), %eax
movl %eax, (%rsp)
callq 0x4660
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x4475
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
andl $0xff, %ecx
callq 0x4840
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x4433
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x44a0
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4970
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: free_2d_uchar
static void free_2d_uchar(unsigned char **ptr, long height)
{
	int i;

	for (i=0; i<height; i++) {
		free(ptr[i]);
	}
	free(ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x44dd
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x44b7
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: do_oil_scale
static void do_oil_scale(unsigned char **input_image, long in_width,
	long in_height, unsigned char **output_image, long out_width,
	long out_height, enum oil_colorspace cs)
{
	struct oil_scale os;
	long i, in_line;

	oil_scale_init(&os, in_height, out_height, in_width, out_width, cs);
	in_line = 0;
	for (i=0; i<out_height; i++) {
		while(oil_scale_slots(&os)) {
			oil_scale_in(&os, input_image[in_line++]);
		}
		oil_scale_out(&os, output_image[i]);
	}
	oil_scale_free(&os);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %esi
movq -0x30(%rbp), %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %eax, %r8d
movl 0x10(%rbp), %r9d
leaq -0x88(%rbp), %rdi
callq 0x1480
movq $0x0, -0x98(%rbp)
movq $0x0, -0x90(%rbp)
movq -0x90(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x45cf
jmp 0x4564
leaq -0x88(%rbp), %rdi
callq 0x1990
cmpl $0x0, %eax
je 0x45a0
movq -0x8(%rbp), %rax
movq -0x98(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x98(%rbp)
movq (%rax,%rcx,8), %rsi
leaq -0x88(%rbp), %rdi
callq 0x1a20
jmp 0x4564
movq -0x20(%rbp), %rax
movq -0x90(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x88(%rbp), %rdi
callq 0x1e50
movq -0x90(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x90(%rbp)
jmp 0x4555
leaq -0x88(%rbp), %rdi
callq 0x1840
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: alloc_2d_ld
static long double **alloc_2d_ld(long width, long height)
{
	long i;
	long double **rows;

	rows = malloc(height * sizeof(long double*));
	for (i=0; i<height; i++) {
		rows[i] = malloc(width * sizeof(long double));
	}
	return rows;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
shlq $0x3, %rdi
callq 0x10e0
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x464d
movq -0x8(%rbp), %rdi
shlq $0x4, %rdi
callq 0x10e0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4619
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: validate_scanline8
static void validate_scanline8(unsigned char *oil, long double *ref,
	size_t width, int cmp)
{
	int i, j, ref_i, pos;
	long double error, ref_f;
	for (i=0; i<width; i++) {
		for (j=0; j<cmp; j++) {
			pos = i * cmp + j;
			ref_f = ref[pos] * 255.0L;
			ref_i = lroundl(ref_f);
			error = fabsl(oil[pos] - ref_f) - 0.5L;
			if (error > worst) {
				worst = error;
			}
			if (error > 0.06L) {
				fprintf(stderr, "[%d:%d] expected: %d, got %d (%.9Lf)\n", i, j, ref_i, oil[pos], ref_f);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x4964
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4954
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
imull %ecx, %eax
movl -0x24(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
fldt (%rax,%rcx)
flds 0x17d3(%rip)            # 0x6078
fmulp %st, %st(1)
fstpt -0x50(%rbp)
fldt -0x50(%rbp)
movq %rsp, %rax
fstpt (%rax)
callq 0x10d0
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x54(%rbp)
fildl -0x54(%rbp)
fldt -0x50(%rbp)
fsubrp %st, %st(1)
fabs
flds 0x17d7(%rip)            # 0x60b0
faddp %st, %st(1)
fstpt -0x40(%rbp)
fldt -0x40(%rbp)
fldt 0xcfe9(%rip)            # 0x118d0
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jbe 0x48fa
jmp 0x48f1
fldt -0x40(%rbp)
fstpt 0xcfd6(%rip)            # 0x118d0
fldt -0x40(%rbp)
fldt 0x17dd(%rip)            # 0x60e0
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jbe 0x4944
jmp 0x490d
movq 0x46e4(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rsi
movzbl (%rax,%rsi), %r9d
fldt -0x50(%rbp)
movq %rsp, %rax
fstpt (%rax)
leaq 0x18fc(%rip), %rsi      # 0x6239
xorl %eax, %eax
callq 0x10c0
jmp 0x4946
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4873
jmp 0x4956
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x485e
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: free_2d_ld
static void free_2d_ld(long double **ptr, long height)
{
	int i;

	for (i=0; i<height; i++) {
		free(ptr[i]);
	}
	free(ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x49ad
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4987
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: preprocess
static void preprocess(long double *in, enum oil_colorspace cs)
{
	switch (cs) {
	case OIL_CS_G:
	case OIL_CS_CMYK:
	case OIL_CS_UNKNOWN:
		break;
	case OIL_CS_GA:
		in[0] *= in[1];
		break;
	case OIL_CS_RGB:
		in[0] = srgb_sample_to_linear_reference(in[0]);
		in[1] = srgb_sample_to_linear_reference(in[1]);
		in[2] = srgb_sample_to_linear_reference(in[2]);
		break;
	case OIL_CS_RGBX:
		in[0] = srgb_sample_to_linear_reference(in[0]);
		in[1] = srgb_sample_to_linear_reference(in[1]);
		in[2] = srgb_sample_to_linear_reference(in[2]);
		in[3] = 0;
		break;
	case OIL_CS_RGBA:
		in[0] = in[3] * srgb_sample_to_linear_reference(in[0]);
		in[1] = in[3] * srgb_sample_to_linear_reference(in[1]);
		in[2] = in[3] * srgb_sample_to_linear_reference(in[2]);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x2, %eax
jb 0x4a1e
jmp 0x49dc
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x4a23
jmp 0x49e6
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0x4a35
jmp 0x49f0
movl -0x10(%rbp), %eax
subl $0x4, %eax
je 0x4a80
jmp 0x49fe
movl -0x10(%rbp), %eax
subl $0x104, %eax            # imm = 0x104
je 0x4ad1
jmp 0x4a0e
movl -0x10(%rbp), %eax
subl $0x204, %eax            # imm = 0x204
jne 0x4b38
jmp 0x4a1e
jmp 0x4b38
movq -0x8(%rbp), %rax
fldt 0x10(%rax)
fldt (%rax)
fmulp %st, %st(1)
fstpt (%rax)
jmp 0x4b38
movq -0x8(%rbp), %rax
fldt (%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x5170
movq -0x8(%rbp), %rax
fstpt (%rax)
movq -0x8(%rbp), %rax
fldt 0x10(%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x5170
movq -0x8(%rbp), %rax
fstpt 0x10(%rax)
movq -0x8(%rbp), %rax
fldt 0x20(%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x5170
movq -0x8(%rbp), %rax
fstpt 0x20(%rax)
jmp 0x4b38
movq -0x8(%rbp), %rax
fldt (%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x5170
movq -0x8(%rbp), %rax
fstpt (%rax)
movq -0x8(%rbp), %rax
fldt 0x10(%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x5170
movq -0x8(%rbp), %rax
fstpt 0x10(%rax)
movq -0x8(%rbp), %rax
fldt 0x20(%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x5170
movq -0x8(%rbp), %rax
fstpt 0x20(%rax)
movq -0x8(%rbp), %rax
fldz
fstpt 0x30(%rax)
jmp 0x4b38
movq -0x8(%rbp), %rax
fldt 0x30(%rax)
fstpt -0x34(%rbp)
fldt (%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x5170
fldt -0x34(%rbp)
fmulp %st, %st(1)
movq -0x8(%rbp), %rax
fstpt (%rax)
movq -0x8(%rbp), %rax
fldt 0x30(%rax)
fstpt -0x28(%rbp)
fldt 0x10(%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x5170
fldt -0x28(%rbp)
fmulp %st, %st(1)
movq -0x8(%rbp), %rax
fstpt 0x10(%rax)
movq -0x8(%rbp), %rax
fldt 0x30(%rax)
fstpt -0x1c(%rbp)
fldt 0x20(%rax)
movq %rsp, %rax
fstpt (%rax)
callq 0x5170
fldt -0x1c(%rbp)
fmulp %st, %st(1)
movq -0x8(%rbp), %rax
fstpt 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: ref_yscale
static void ref_yscale(long double **in, long width, long in_height,
	long double **out, long out_height, long cmp)
{
	long i;
	long double *transposed, *trans_scaled;

	transposed = malloc(in_height * cmp * sizeof(long double));
	trans_scaled = malloc(out_height * cmp * sizeof(long double));
	for (i=0; i<width; i++) {
		ref_transpose_column(in, in_height, transposed, i * cmp, cmp);
		ref_xscale(transposed, in_height, trans_scaled, out_height, cmp);
		ref_transpose_line(trans_scaled, out_height, out, i * cmp, cmp);
	}
	free(transposed);
	free(trans_scaled);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rdi
imulq -0x30(%rbp), %rdi
shlq $0x4, %rdi
callq 0x10e0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
imulq -0x30(%rbp), %rdi
shlq $0x4, %rdi
callq 0x10e0
movq %rax, -0x48(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x4ec1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
imulq -0x30(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x5650
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x4b40
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rcx
imulq -0x30(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x56e0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x4e54
movq -0x40(%rbp), %rdi
callq 0x1030
movq -0x48(%rbp), %rdi
callq 0x1030
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: srgb_sample_to_linear_reference
static long double srgb_sample_to_linear_reference(long double in_f)
{
	long double tmp;
	if (in_f <= 0.0404482362771082L) {
		return in_f / 12.92L;
	} else {
		tmp = ((in_f + 0.055L)/1.055L);
		return powl(tmp, 2.4L);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
fldt 0x10(%rbp)
fstpt -0x20(%rbp)
fldt -0x20(%rbp)
fldt 0xf69(%rip)             # 0x60f0
fucompi %st(1), %st
fstp %st(0)
jb 0x519f
jmp 0x518f
fldt -0x20(%rbp)
fldt 0xf98(%rip)             # 0x6130
fdivrp %st, %st(1)
fstpt -0x10(%rbp)
jmp 0x51ce
fldt -0x20(%rbp)
fldt 0xf58(%rip)             # 0x6100
faddp %st, %st(1)
fldt 0xf60(%rip)             # 0x6110
fdivrp %st, %st(1)
fstpt -0x30(%rbp)
fldt -0x30(%rbp)
movq %rsp, %rax
fldt 0xf5f(%rip)             # 0x6120
fstpt 0x10(%rax)
fstpt (%rax)
callq 0x10f0
fstpt -0x10(%rbp)
fldt -0x10(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: calc_taps_check
static long calc_taps_check(long dim_in, long dim_out)
{
	long tmp_i;
	if (dim_in < dim_out) {
		return 4;
	}
	tmp_i = dim_in * 4 / dim_out;
	return tmp_i - (tmp_i%2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x5200
movq $0x4, -0x8(%rbp)
jmp 0x5233
movq -0x10(%rbp), %rax
shlq $0x2, %rax
cqto
idivq -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq -0x28(%rbp), %rax
subq %rdx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: split_map_check
static long double split_map_check(long dim_in, long dim_out, long pos,
	long double *ty)
{
	long double smp;
	long smp_i;

	smp = ref_map(dim_in, dim_out, pos);
	smp_i = floorl(smp);
	*ty = smp - smp_i;
	return smp_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x54b0
fstpt -0x30(%rbp)
fldt -0x30(%rbp)
movq %rsp, %rax
fstpt (%rax)
callq 0x1050
fnstcw -0x52(%rbp)
movzwl -0x52(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x54(%rbp)
fldcw -0x54(%rbp)
fistpll -0x50(%rbp)
fldcw -0x52(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
fldt -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
fildll -0x48(%rbp)
fsubrp %st, %st(1)
movq -0x20(%rbp), %rax
fstpt (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
fildll -0x40(%rbp)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: ref_calc_coeffs
static void ref_calc_coeffs(long double *coeffs, long double offset, long taps,
	long ltrim, long rtrim)
{
	long i;
	long double tap_offset, tap_mult, fudge, total_check;

	assert(taps - ltrim - rtrim > 0);
	tap_mult = (long double)taps / 4;
	fudge = 0.0;
	for (i=0; i<taps; i++) {
		if (i<ltrim || i>=taps-rtrim) {
			coeffs[i] = 0;
			continue;
		}
		tap_offset = 1 - offset - taps / 2 + i;
		coeffs[i] = ref_catrom(fabsl(tap_offset) / tap_mult) / tap_mult;
		fudge += coeffs[i];
	}
	total_check = 0.0;
	for (i=0; i<taps; i++) {
		coeffs[i] /= fudge;
		total_check += coeffs[i];
	}
	assert(fabsl(total_check - 1.0) < 0.0000000001L);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
fldt 0x10(%rbp)
movq %rdi, -0x8(%rbp)
fstpt -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
subq -0x38(%rbp), %rax
cmpq $0x0, %rax
jle 0x5305
jmp 0x5324
leaq 0xea1(%rip), %rdi       # 0x61ad
leaq 0xeb3(%rip), %rsi       # 0x61c6
movl $0x45, %edx
leaq 0xeae(%rip), %rcx       # 0x61cd
callq 0x1080
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
fildll -0x88(%rbp)
flds 0xd79(%rip)             # 0x60b4
fmulp %st, %st(1)
fstpt -0x60(%rbp)
fldz
fstpt -0x70(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x5416
movq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
jl 0x5376
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq -0x38(%rbp), %rcx
cmpq %rcx, %rax
jl 0x5389
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
shlq $0x4, %rcx
fldz
fstpt (%rax,%rcx)
jmp 0x5405
fldt -0x20(%rbp)
fld1
fsubp %st, %st(1)
movq -0x28(%rbp), %rax
movq %rax, %rcx
shrq $0x3f, %rcx
addq %rcx, %rax
sarq %rax
movq %rax, -0x90(%rbp)
fildll -0x90(%rbp)
fsubrp %st, %st(1)
movq -0x40(%rbp), %rax
movq %rax, -0x98(%rbp)
fildll -0x98(%rbp)
faddp %st, %st(1)
fstpt -0x50(%rbp)
fldt -0x50(%rbp)
fabs
fldt -0x60(%rbp)
fdivrp %st, %st(1)
movq %rsp, %rax
fstpt (%rax)
callq 0x5500
fldt -0x60(%rbp)
fdivrp %st, %st(1)
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
shlq $0x4, %rcx
fstpt (%rax,%rcx)
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
shlq $0x4, %rcx
fldt (%rax,%rcx)
fldt -0x70(%rbp)
faddp %st, %st(1)
fstpt -0x70(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x534d
fldz
fstpt -0x80(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x5469
fldt -0x70(%rbp)
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
shlq $0x4, %rcx
fldt (%rax,%rcx)
fdivp %st, %st(1)
fstpt (%rax,%rcx)
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
shlq $0x4, %rcx
fldt (%rax,%rcx)
fldt -0x80(%rbp)
faddp %st, %st(1)
fstpt -0x80(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x5423
fldt -0x80(%rbp)
fld1
fchs
faddp %st, %st(1)
fabs
fldt 0xcc6(%rip)             # 0x6140
fucompi %st(1), %st
fstp %st(0)
jbe 0x5484
jmp 0x5482
jmp 0x54a3
leaq 0xd85(%rip), %rdi       # 0x6210
leaq 0xd34(%rip), %rsi       # 0x61c6
movl $0x56, %edx
leaq 0xd2f(%rip), %rcx       # 0x61cd
callq 0x1080
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: cubic
static long double cubic(long double b, long double c, long double x)
{
	if (x<1.0l) {
		return (
			(12.0l - 9.0l * b - 6.0l * c) * x*x*x +
			(-18.0l + 12.0l * b + 6.0l * c) * x*x +
			(6.0l -  2.0l * b)
		) / 6.0l;
	}
	if (x<2.0l) {
		return (
			(-b - 6.0l * c) * x*x*x +
			(6.0l * b + 30.0l * c) * x*x +
			(-12.0l * b - 48.0l * c) * x +
			(8.0l * b + 24.0l * c)
		) / 6.0l;
	}
	return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
fldt 0x30(%rbp)
fldt 0x20(%rbp)
fldt 0x10(%rbp)
fstpt -0x20(%rbp)
fstpt -0x30(%rbp)
fstpt -0x40(%rbp)
fldt -0x40(%rbp)
fld1
fucompi %st(1), %st
fstp %st(0)
jbe 0x55c0
jmp 0x5563
fldt -0x20(%rbp)
flds 0xb68(%rip)             # 0x60d4
fmul %st(1), %st
flds 0xb64(%rip)             # 0x60d8
fadd %st, %st(1)
fldt -0x30(%rbp)
flds 0xb39(%rip)             # 0x60b8
fmul %st(1), %st
faddp %st, %st(3)
fldt -0x40(%rbp)
fmul %st, %st(3)
fmul %st, %st(3)
fxch %st(2)
fmul %st(4), %st
flds 0xb48(%rip)             # 0x60dc
faddp %st, %st(1)
flds 0xb24(%rip)             # 0x60c0
fmul %st, %st(2)
fxch %st(2)
faddp %st, %st(1)
fmul %st(2), %st
fmul %st(2), %st
fxch %st(3)
fmulp %st, %st(2)
fxch %st(1)
faddp %st, %st(2)
fxch %st(2)
fadd %st, %st(0)
fsubr %st(2), %st
faddp %st, %st(1)
fdivp %st, %st(1)
fstpt -0x10(%rbp)
jmp 0x5642
fldt -0x40(%rbp)
flds 0xabb(%rip)             # 0x6084
fucompi %st(1), %st
fstp %st(0)
jbe 0x563d
jmp 0x55d1
fldt -0x20(%rbp)
fldt -0x30(%rbp)
flds 0xadb(%rip)             # 0x60b8
fmul %st(1), %st
fsub %st(2), %st
fldt -0x40(%rbp)
fmul %st, %st(1)
fmul %st, %st(1)
flds 0xace(%rip)             # 0x60bc
fmul %st(3), %st
flds 0xaca(%rip)             # 0x60c0
fld %st(5)
fmul %st(1), %st
faddp %st, %st(2)
fxch %st(1)
fmul %st(2), %st
fmul %st(2), %st
fxch %st(3)
fmul %st(2), %st
faddp %st, %st(3)
flds 0xab6(%rip)             # 0x60c4
fmul %st(4), %st
flds 0xab2(%rip)             # 0x60c8
fmul %st(6), %st
faddp %st, %st(1)
fmulp %st, %st(2)
fxch %st(1)
faddp %st, %st(2)
flds 0xaa6(%rip)             # 0x60cc
fmulp %st, %st(3)
flds 0xaa2(%rip)             # 0x60d0
fmulp %st, %st(4)
fxch %st(3)
faddp %st, %st(2)
faddp %st, %st(1)
fdivp %st, %st(1)
fstpt -0x10(%rbp)
jmp 0x5642
fldz
fstpt -0x10(%rbp)
fldt -0x10(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: ref_transpose_column
static void ref_transpose_column(long double **in, long height,
	long double *out, long in_offset, long cmp)
{
	long i, j;
	for (i=0; i<height; i++) {
		for (j=0; j<cmp; j++) {
			out[i * cmp + j] = in[i][in_offset + j];
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x56de
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x56ce
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq %rdx, %rsi
shlq $0x4, %rsi
fldt (%rax,%rsi)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rsi
imulq %rsi, %rcx
addq %rdx, %rcx
shlq $0x4, %rcx
fstpt (%rax,%rcx)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x5682
jmp 0x56d0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5670
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: ref_transpose_line
static void ref_transpose_line(long double *in, long width,
	long double **out, long out_offset, long cmp)
{
	long i, j;
	for (i=0; i<width; i++) {
		for (j=0; j<cmp; j++) {
			out[i][out_offset + j] = in[i * cmp + j];
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x5771
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x5761
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq %rcx, %rsi
imulq %rdx, %rsi
movq -0x38(%rbp), %rdx
addq %rdx, %rsi
shlq $0x4, %rsi
fldt (%rax,%rsi)
movq -0x18(%rbp), %rax
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
addq %rdx, %rcx
shlq $0x4, %rcx
fstpt (%rax,%rcx)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x5712
jmp 0x5763
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5700
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: clamp_f
static long double clamp_f(long double in)
{
	if (in <= 0.0L) {
		return 0.0L;
	}
	if (in >= 1.0L) {
		return 1.0L;
	}
	return in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
fldt 0x10(%rbp)
fstpt -0x20(%rbp)
fldt -0x20(%rbp)
fldz
fucompi %st(1), %st
fstp %st(0)
jb 0x579e
jmp 0x5797
fldz
fstpt -0x10(%rbp)
jmp 0x57ba
fldt -0x20(%rbp)
fld1
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jb 0x57b4
jmp 0x57ad
fld1
fstpt -0x10(%rbp)
jmp 0x57ba
fldt -0x20(%rbp)
fstpt -0x10(%rbp)
fldt -0x10(%rbp)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: linear_sample_to_srgb_reference
static long double linear_sample_to_srgb_reference(long double in_f)
{
	long double tmp;
	if (in_f <= 0.0L) {
		return 0.0L;
	}
	if (in_f >= 1.0L) {
		return 1.0L;
	}
	if (in_f <= 0.00313066844250063L) {
		return in_f * 12.92L;
	} else {
		tmp = powl(in_f, 1/2.4L);
		return 1.055L * tmp - 0.055L;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
fldt 0x10(%rbp)
fstpt -0x20(%rbp)
fldt -0x20(%rbp)
fldz
fucompi %st(1), %st
fstp %st(0)
jb 0x57e2
jmp 0x57db
fldz
fstpt -0x10(%rbp)
jmp 0x5848
fldt -0x20(%rbp)
fld1
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jb 0x57f8
jmp 0x57f1
fld1
fstpt -0x10(%rbp)
jmp 0x5848
fldt -0x20(%rbp)
fldt 0x94f(%rip)             # 0x6150
fucompi %st(1), %st
fstp %st(0)
jb 0x5819
jmp 0x5809
fldt -0x20(%rbp)
fldt 0x91e(%rip)             # 0x6130
fmulp %st, %st(1)
fstpt -0x10(%rbp)
jmp 0x5848
fldt -0x20(%rbp)
movq %rsp, %rax
fldt 0x93b(%rip)             # 0x6160
fstpt 0x10(%rax)
fstpt (%rax)
callq 0x10f0
fstpt -0x30(%rbp)
fldt -0x30(%rbp)
fldt 0x8d5(%rip)             # 0x6110
fmulp %st, %st(1)
fldt 0x92d(%rip)             # 0x6170
faddp %st, %st(1)
fstpt -0x10(%rbp)
fldt -0x10(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/test.c
// Function: test_scale_catrom_extremes
static void test_scale_catrom_extremes()
{
	unsigned char **input_image;

	/* Allocate & populate input image */
	input_image = alloc_2d_uchar(4, 4);

	input_image[0][0] = 0;
	input_image[0][1] = 0;
	input_image[0][2] = 0;
	input_image[0][3] = 0;

	input_image[1][0] = 0;
	input_image[1][1] = 255;
	input_image[1][2] = 255;
	input_image[1][3] = 0;

	input_image[2][0] = 0;
	input_image[2][1] = 255;
	input_image[2][2] = 255;
	input_image[2][3] = 0;

	input_image[3][0] = 0;
	input_image[3][1] = 0;
	input_image[3][2] = 0;
	input_image[3][3] = 0;

	test_scale(4, 4, input_image, 7, 7, OIL_CS_G);
	free_2d_uchar(input_image, 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x4, %esi
movq %rsi, %rdi
callq 0x42d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb $0x0, 0x2(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb $0x0, 0x3(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb $-0x1, 0x1(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb $-0x1, 0x2(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x3(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb $-0x1, 0x1(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb $-0x1, 0x2(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb $0x0, 0x3(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x0, 0x2(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x0, 0x3(%rax)
movq -0x8(%rbp), %rdx
movl $0x4, %esi
movl $0x7, %r8d
movl $0x1, %r9d
movq %rsi, %rdi
movq %r8, %rcx
callq 0x4390
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x44a0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/utils/bplus_tree/test/test_bplus_tree.c
// Function: compare
int compare(void *a, void *b) {
    int aa = *(int *)a;
    int bb = *(int *)b;
    if (aa == bb) {
        return 0;
    } else if (aa > bb) {
        return 1;
    } else {
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x226f
movl $0x0, -0x4(%rbp)
jmp 0x2287
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x2280
movl $0x1, -0x4(%rbp)
jmp 0x2287
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: copyFileName
static 
void copyFileName ( Char* to, Char* from ) 
{
   if ( strlen(from) > FILE_NAME_LEN-10 )  {
      fprintf (
         stderr,
         "bzip2: file name\n`%s'\n"
         "is suspiciously (more than %d chars) long.\n"
         "Try using a reasonable file name instead.  Sorry! :-)\n",
         from, FILE_NAME_LEN-10
      );
      setExit(1);
      exit(exitValue);
   }

  strncpy(to,from,FILE_NAME_LEN-10);
  to[FILE_NAME_LEN-10]='\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20f0
cmpq $0x400, %rax            # imm = 0x400
jbe 0x3097
movq 0x19f90(%rip), %rax     # 0x1cff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x15c42(%rip), %rsi     # 0x18cb8
movl $0x400, %ecx            # imm = 0x400
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x4400
movl 0x1ae06(%rip), %edi     # 0x1de98
callq 0x2240
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2070
movq -0x8(%rbp), %rax
movb $0x0, 0x400(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: addFlagsFromEnvVar
static 
void addFlagsFromEnvVar ( Cell** argList, Char* varName ) 
{
   Int32 i, j, k;
   Char *envbase, *p;

   envbase = getenv(varName);
   if (envbase != NULL) {
      p = envbase;
      i = 0;
      while (True) {
         if (p[i] == 0) break;
         p += i;
         i = 0;
         while (isspace((Int32)(p[0]))) p++;
         while (p[i] != 0 && !isspace((Int32)(p[i]))) i++;
         if (i > 0) {
            k = i; if (k > FILE_NAME_LEN-10) k = FILE_NAME_LEN-10;
            for (j = 0; j < k; j++) tmpName[j] = p[j];
            tmpName[k] = 0;
            APPEND_FLAG(*argList, tmpName);
         }
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2030
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x322c
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x310d
jmp 0x322a
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
callq 0x2280
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x3153
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3125
jmp 0x3155
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0x3196
callq 0x2280
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x319f
jmp 0x31aa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3155
cmpl $0x0, -0x14(%rbp)
jle 0x3225
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x400, -0x1c(%rbp)     # imm = 0x400
jle 0x31c6
movl $0x400, -0x1c(%rbp)     # imm = 0x400
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x31f9
movq -0x30(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movslq -0x18(%rbp), %rcx
leaq 0x1b905(%rip), %rax     # 0x1eaf0
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x31cd
movslq -0x1c(%rbp), %rcx
leaq 0x1b8ec(%rip), %rax     # 0x1eaf0
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x1b8da(%rip), %rsi     # 0x1eaf0
callq 0x3240
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x30f7
jmp 0x322c
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: snocString
static 
Cell *snocString ( Cell *root, Char *name )
{
   if (root == NULL) {
      Cell *tmp = mkCell();
      tmp->name = (Char*) myMalloc ( 5 + strlen(name) );
      strcpy ( tmp->name, name );
      return tmp;
   } else {
      Cell *tmp = root;
      while (tmp->link != NULL) tmp = tmp->link;
      tmp->link = snocString ( tmp->link, name );
      return root;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3298
callq 0x4a20
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20f0
addq $0x5, %rax
movl %eax, %edi
callq 0x4a60
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x20a0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x32dd
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x32b9
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x32a0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3240
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: mySignalCatcher
static 
void mySignalCatcher ( IntNative n )
{
   fprintf ( stderr,
             "\n%s: Control-C or similar caught, quitting.\n",
             progName );
   cleanUpAndFail(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x19c36(%rip), %rax     # 0x1cff8
movq (%rax), %rdi
movq 0x1b704(%rip), %rdx     # 0x1ead0
leaq 0x16095(%rip), %rsi     # 0x19468
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x4820
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: outOfMemory
static 
void outOfMemory ( void )
{
   fprintf ( stderr,
             "\n%s: couldn't allocate enough memory\n",
             progName );
   showFileNames();
   cleanUpAndFail(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1855d(%rip), %rax     # 0x1cff8
movq (%rax), %rdi
movq 0x1a02b(%rip), %rdx     # 0x1ead0
leaq 0x14284(%rip), %rsi     # 0x18d30
movb $0x0, %al
callq 0x2170
callq 0x47e0
movl $0x1, %edi
callq 0x4820
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: panic
static 
void panic ( const Char* s )
{
   fprintf ( stderr,
             "\n%s: PANIC -- internal consistency error:\n"
             "\t%s\n"
             "\tThis is a BUG.  Please report it to me at:\n"
             "\tjseward@bzip.org\n",
             progName, s );
   showFileNames();
   cleanUpAndFail( 3 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x18515(%rip), %rax     # 0x1cff8
movq (%rax), %rdi
movq 0x19fe3(%rip), %rdx     # 0x1ead0
movq -0x8(%rbp), %rcx
leaq 0x14b41(%rip), %rsi     # 0x19639
movb $0x0, %al
callq 0x2170
callq 0x47e0
movl $0x3, %edi
callq 0x4820
nop
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: fileExists
static 
Bool fileExists ( Char* name )
{
   FILE *tmp   = fopen ( name, "rb" );
   Bool exists = (tmp != NULL);
   if (tmp != NULL) fclose ( tmp );
   return exists;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x14acf(%rip), %rsi     # 0x19606
callq 0x2210
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4b60
movq -0x10(%rbp), %rdi
callq 0x20e0
movb -0x11(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: hasSuffix
static 
Bool hasSuffix ( Char* s, const Char* suffix )
{
   Int32 ns = strlen(s);
   Int32 nx = strlen(suffix);
   if (ns < nx) return False;
   if (strcmp(s + ns - nx, suffix) == 0) return True;
   return False;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20f0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20f0
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x4ba6
movb $0x0, -0x1(%rbp)
jmp 0x4bd5
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
movslq -0x20(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2150
cmpl $0x0, %eax
jne 0x4bd1
movb $0x1, -0x1(%rbp)
jmp 0x4bd5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: notAStandardFile
static 
Bool notAStandardFile ( Char* name )
{
   IntNative      i;
   struct MY_STAT statBuf;

   i = MY_LSTAT ( name, &statBuf );
   if (i != 0) return True;
   if (MY_S_ISREG(statBuf.st_mode)) return False;
   return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x2140
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x4c0e
movb $0x1, -0x1(%rbp)
jmp 0x4c2a
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x4c26
movb $0x0, -0x1(%rbp)
jmp 0x4c2a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: fopen_output_safely
static
FILE* fopen_output_safely ( Char* name, const char* mode )
{
#  if BZ_UNIX
   FILE*     fp;
   IntNative fh;
   fh = open(name, O_WRONLY|O_CREAT|O_EXCL, S_IWUSR|S_IRUSR);
   if (fh == -1) return NULL;
   fp = fdopen(fh, mode);
   if (fp == NULL) close(fh);
   return fp;
#  else
   return fopen(name, mode);
#  endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xc1, %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x21f0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x4cf8
movq $0x0, -0x8(%rbp)
jmp 0x4d1f
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x21d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4d17
movl -0x24(%rbp), %edi
callq 0x2130
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: pad
static 
void pad ( Char *s )
{
   Int32 i;
   if ( (Int32)strlen(s) >= longestFileName ) return;
   for (i = 1; i <= longestFileName - (Int32)strlen(s); i++)
      fprintf ( stderr, " " );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20f0
cmpl 0x19d8d(%rip), %eax     # 0x1ead8
jl 0x4d4f
jmp 0x4da0
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl 0x19d76(%rip), %eax     # 0x1ead8
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20f0
movl -0x14(%rbp), %ecx
movq %rax, %rdx
movl -0x10(%rbp), %eax
subl %edx, %ecx
cmpl %ecx, %eax
jg 0x4da0
movq 0x18274(%rip), %rax     # 0x1cff8
movq (%rax), %rdi
leaq 0x15478(%rip), %rsi     # 0x1a206
movb $0x0, %al
callq 0x2170
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4d56
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: applySavedTimeInfoToOutputFile
static 
void applySavedTimeInfoToOutputFile ( Char *dstName )
{
#  if BZ_UNIX
   IntNative      retVal;
   struct utimbuf uTimBuf;

   uTimBuf.actime = fileMetaInfo.st_atime;
   uTimBuf.modtime = fileMetaInfo.st_mtime;

   retVal = utime ( dstName, &uTimBuf );
   ERROR_IF_NOT_ZERO ( retVal );
#  endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x19da5(%rip), %rax     # 0x1ef48
movq %rax, -0x20(%rbp)
movq 0x19daa(%rip), %rax     # 0x1ef58
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2040
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x51cd
callq 0x51e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: ioError
static 
void ioError ( void )
{
   fprintf ( stderr,
             "\n%s: I/O or other error, bailing out.  "
             "Possible reason follows.\n",
             progName );
   perror ( progName );
   showFileNames();
   cleanUpAndFail( 1 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x17e0d(%rip), %rax     # 0x1cff8
movq (%rax), %rdi
movq 0x198db(%rip), %rdx     # 0x1ead0
leaq 0x145e5(%rip), %rsi     # 0x197e1
movb $0x0, %al
callq 0x2170
movq 0x198c6(%rip), %rdi     # 0x1ead0
callq 0x2220
callq 0x47e0
movl $0x1, %edi
callq 0x4820
nop
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: uInt64_from_UInt32s
static
void uInt64_from_UInt32s ( UInt64* n, UInt32 lo32, UInt32 hi32 )
{
   n->b[7] = (UChar)((hi32 >> 24) & 0xFF);
   n->b[6] = (UChar)((hi32 >> 16) & 0xFF);
   n->b[5] = (UChar)((hi32 >> 8)  & 0xFF);
   n->b[4] = (UChar) (hi32        & 0xFF);
   n->b[3] = (UChar)((lo32 >> 24) & 0xFF);
   n->b[2] = (UChar)((lo32 >> 16) & 0xFF);
   n->b[1] = (UChar)((lo32 >> 8)  & 0xFF);
   n->b[0] = (UChar) (lo32        & 0xFF);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x7(%rax)
movl -0x10(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x6(%rax)
movl -0x10(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x5(%rax)
movl -0x10(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x4(%rax)
movl -0xc(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2.c
// Function: uInt64_to_double
static
double uInt64_to_double ( UInt64* n )
{
   Int32  i;
   double base = 1.0;
   double sum  = 0.0;
   for (i = 0; i < 8; i++) {
      sum  += base * (double)(n->b[i]);
      base *= 256.0;
   }
   return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd 0x12e00(%rip), %xmm0    # 0x18170
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x53ce
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cvtsi2sd %eax, %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x12dc7(%rip), %xmm0    # 0x18180
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5384
movsd -0x20(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)