LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: oil_fix_ratio
int oil_fix_ratio(int src_width, int src_height, int *out_width,
	int *out_height)
{
	double width_ratio, height_ratio, tmp;
	int *adjust_dim;

	if (src_width < 1 || src_height < 1 || *out_width < 1 || *out_height < 1) {
		return -1; // bad argument
	}

	width_ratio = *out_width / (double)src_width;
	height_ratio = *out_height / (double)src_height;
	if (width_ratio < height_ratio) {
		tmp = round(width_ratio * src_height);
		adjust_dim = out_height;
	} else {
		tmp = round(height_ratio * src_width);
		adjust_dim = out_width;
	}
	if (tmp > INT_MAX) {
		return -2; // adjusted dimension out of range
	}
	*adjust_dim = tmp ? tmp : 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x1, -0x8(%rbp)
jl 0x2134
cmpl $0x1, -0xc(%rbp)
jl 0x2134
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jl 0x2134
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jge 0x2140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x221d
movq -0x18(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
cvtsi2sdl -0x8(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x219e
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x1040
movsd %xmm0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x21be
movsd -0x30(%rbp), %xmm0
cvtsi2sdl -0x8(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x1040
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
movsd 0x3e8d(%rip), %xmm1     # 0x6058
ucomisd %xmm1, %xmm0
jbe 0x21da
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x221d
movsd -0x38(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x21ec
jp 0x21ec
jmp 0x21f8
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x2207
movsd 0x3e60(%rip), %xmm0     # 0x6060
movsd %xmm0, -0x48(%rbp)
jmp 0x2207
movsd -0x48(%rbp), %xmm0
cvttsd2si %xmm0, %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: scale_up_coeffs
static void scale_up_coeffs(int in_width, int out_width, float *coeff_buf,
	int *border_buf)
{
	int i, smp_i, start, end, ltrim, rtrim, safe_end, max_pos;
	float tx;

	max_pos = in_width - 1;
	for (i=0; i<out_width; i++) {
		smp_i = split_map(in_width, out_width, i, &tx);
		start = smp_i - 1;
		end = smp_i + 2;

		// This is the border position at which we will tell the
		// interpolator to calculate the output sample.
		safe_end = min(end, max_pos);

		ltrim = 0;
		rtrim = 0;
		if (start < 0) {
			ltrim = -1 * start;
		}
		if (end > max_pos) {
			rtrim = end - max_pos;
		}

		border_buf[safe_end] += 1;

		// we offset coeff_buf by rtrim because the interpolator won't
		// be pushing any more samples into its sample buffer.
		calc_coeffs(coeff_buf + rtrim, tx, 4, ltrim, rtrim);

		coeff_buf += 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2575
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0x1c(%rbp), %edx
leaq -0x3c(%rbp), %rcx
callq 0x2580
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
movl -0x38(%rbp), %esi
callq 0x2230
movl %eax, -0x34(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x2515
imull $0xffffffff, -0x24(%rbp), %eax # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x38(%rbp), %eax
jle 0x2526
movl -0x28(%rbp), %eax
subl -0x38(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movss -0x3c(%rbp), %xmm0
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
movl $0x4, %esi
callq 0x2600
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x24b6
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: split_map
static int split_map(int dim_in, int dim_out, int pos, float *rest)
{
	double smp;
	int smp_i;

	smp = map(dim_in, dim_out, pos);
	smp_i = smp < 0 ? -1 : smp;
	*rest = smp - smp_i;
	return smp_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x2730
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x25c1
movsd 0x3aae(%rip), %xmm0     # 0x6068
movsd %xmm0, -0x30(%rbp)
jmp 0x25cb
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x24(%rbp)
movsd -0x20(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: calc_coeffs
static void calc_coeffs(float *coeffs, float tx, int taps, int ltrim, int rtrim)
{
	int i;
	float tmp, tap_mult, fudge;

	tap_mult = (float)taps / TAPS;
	tx = 1 - tx - taps / 2 + ltrim;
	fudge = 0.0f;

	for (i=ltrim; i<taps-rtrim; i++) {
		tmp = catrom(fabsf(tx) / tap_mult) / tap_mult;
		fudge += tmp;
		coeffs[i] = tmp;
		tx += 1;
	}
	fudge = 1 / fudge;
	for (i=ltrim; i<taps-rtrim; i++) {
		coeffs[i] *= fudge;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cvtsi2ssl -0x10(%rbp), %xmm0
movss 0x3a59(%rip), %xmm1     # 0x6080
divss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movss 0x3a44(%rip), %xmm0     # 0x607c
subss -0xc(%rbp), %xmm0
movl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cvtsi2ss %eax, %xmm1
subss %xmm1, %xmm0
cvtsi2ssl -0x14(%rbp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x10(%rbp), %ecx
subl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x26db
movss -0xc(%rbp), %xmm0
movaps 0x3a1b(%rip), %xmm1     # 0x60a0
pand %xmm1, %xmm0
divss -0x24(%rbp), %xmm0
callq 0x2770
divss -0x24(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
addss -0x28(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movss 0x39b6(%rip), %xmm0     # 0x607c
addss -0xc(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x266c
movss 0x3999(%rip), %xmm0     # 0x607c
divss -0x28(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x10(%rbp), %ecx
subl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x2722
movss -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x26f3
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: xscale_down_rgbx
static void xscale_down_rgbx(unsigned char *in, float *out,
	int out_width, float *coeff_buf, int *border_buf)
{
	int i, j, k;
	float sum[3][4] = {{ 0.0f }};

	for (i=0; i<out_width; i++) {
		for (j=0; j<border_buf[i]; j++) {
			for (k=0; k<3; k++) {
				add_sample_to_sum_f(s2l_map[in[k]], coeff_buf, sum[k]);
			}
			in += 4;
			coeff_buf += 4;
		}
		dump_out(out, sum, 3);
		out += 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1090
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x290e
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x28e2
movl $0x0, -0x34(%rbp)
cmpl $0x3, -0x34(%rbp)
jge 0x28bf
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x6819(%rip), %rax      # 0x90b0
movss (%rax,%rcx,4), %xmm0
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rax
leaq -0x70(%rbp), %rsi
shlq $0x4, %rax
addq %rax, %rsi
callq 0x2e40
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x287c
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2865
movq -0x10(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x3, %edx
callq 0x2ea0
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2852
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: xscale_down_rgb
static void xscale_down_rgb(unsigned char *in, float *out,
	int out_width, float *coeff_buf, int *border_buf)
{
	int i, j, k;
	float sum[3][4] = {{ 0.0f }};

	for (i=0; i<out_width; i++) {
		for (j=0; j<border_buf[i]; j++) {
			for (k=0; k<3; k++) {
				add_sample_to_sum_f(s2l_map[in[k]], coeff_buf, sum[k]);
			}
			in += 3;
			coeff_buf += 4;
		}
		dump_out(out, sum, 3);
		out += 3;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1090
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2a0e
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x29e2
movl $0x0, -0x34(%rbp)
cmpl $0x3, -0x34(%rbp)
jge 0x29bf
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x6719(%rip), %rax      # 0x90b0
movss (%rax,%rcx,4), %xmm0
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rax
leaq -0x70(%rbp), %rsi
shlq $0x4, %rax
addq %rax, %rsi
callq 0x2e40
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x297c
movq -0x8(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2965
movq -0x10(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x3, %edx
callq 0x2ea0
movq -0x10(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x10(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2952
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: xscale_down_g
static void xscale_down_g(unsigned char *in, float *out,
	int out_width, float *coeff_buf, int *border_buf)
{
	int i, j;
	float sum[4] = { 0.0f };

	for (i=0; i<out_width; i++) {
		for (j=0; j<border_buf[i]; j++) {
			add_sample_to_sum_f(i2f_map[in[0]], coeff_buf, sum);
			in += 1;
			coeff_buf += 4;
		}
		out[0] = sum[0];
		shift_left_f(sum);
		out += 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2aea
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2aba
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xea4b(%rip), %rax      # 0x114d0
movss (%rax,%rcx,4), %xmm0
movq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2e40
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2a65
movss -0x40(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x2f10
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2a52
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: xscale_down_cmyk
static void xscale_down_cmyk(unsigned char *in, float *out,
	int out_width, float *coeff_buf, int *border_buf)
{
	int i, j, k;
	float sum[4][4] = {{ 0.0f }};

	for (i=0; i<out_width; i++) {
		for (j=0; j<border_buf[i]; j++) {
			for (k=0; k<4; k++) {
				add_sample_to_sum_f(i2f_map[in[k]], coeff_buf, sum[k]);
			}
			in += 4;
			coeff_buf += 4;
		}
		dump_out(out, sum, 4);
		out += 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1090
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2be1
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2bb5
movl $0x0, -0x34(%rbp)
cmpl $0x4, -0x34(%rbp)
jge 0x2b92
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xe966(%rip), %rax      # 0x114d0
movss (%rax,%rcx,4), %xmm0
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rax
leaq -0x80(%rbp), %rsi
shlq $0x4, %rax
addq %rax, %rsi
callq 0x2e40
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2b4f
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2b38
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movl $0x4, %edx
callq 0x2ea0
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2b25
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: xscale_down_rgba
static void xscale_down_rgba(unsigned char *in, float *out,
	int out_width, float *coeff_buf, int *border_buf)
{
	int i, j, k;
	float alpha, sum[4][4] = {{ 0.0f }};

	for (i=0; i<out_width; i++) {
		for (j=0; j<border_buf[i]; j++) {
			alpha = i2f_map[in[3]];
			for (k=0; k<3; k++) {
				add_sample_to_sum_f(s2l_map[in[k]] * alpha, coeff_buf, sum[k]);
			}
			add_sample_to_sum_f(alpha, coeff_buf, sum[3]);
			in += 4;
			coeff_buf += 4;
		}
		dump_out(out, sum, 4);
		out += 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1090
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2d1e
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2cf2
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %eax
movl %eax, %ecx
leaq 0xe873(%rip), %rax      # 0x114d0
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x3, -0x34(%rbp)
jge 0x2cb6
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x6427(%rip), %rax      # 0x90b0
movss (%rax,%rcx,4), %xmm0
mulss -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rax
leaq -0x80(%rbp), %rsi
shlq $0x4, %rax
addq %rax, %rsi
callq 0x2e40
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2c6e
movss -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rdi
leaq -0x80(%rbp), %rsi
addq $0x30, %rsi
callq 0x2e40
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2c38
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movl $0x4, %edx
callq 0x2ea0
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2c25
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: xscale_down_ga
static void xscale_down_ga(unsigned char *in, float *out,
	int out_width, float *coeff_buf, int *border_buf)
{
	int i, j;
	float alpha, sum[2][4] = {{ 0.0f }};

	for (i=0; i<out_width; i++) {
		for (j=0; j<border_buf[i]; j++) {
			alpha = i2f_map[in[1]];
			add_sample_to_sum_f(i2f_map[in[0]] * alpha, coeff_buf, sum[0]);
			add_sample_to_sum_f(alpha, coeff_buf, sum[1]);
			in += 2;
			coeff_buf += 4;
		}
		dump_out(out, sum, 2);
		out += 2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1090
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2e2f
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2e03
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, %ecx
leaq 0xe73a(%rip), %rax      # 0x114d0
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xe720(%rip), %rax      # 0x114d0
movss (%rax,%rcx,4), %xmm0
mulss -0x34(%rbp), %xmm0
movq -0x20(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2e40
movss -0x34(%rbp), %xmm0
movq -0x20(%rbp), %rdi
leaq -0x60(%rbp), %rsi
addq $0x10, %rsi
callq 0x2e40
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2d75
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x2, %edx
callq 0x2ea0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2d62
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: dump_out
static void dump_out(float *out, float sum[][4], int n)
{
	int i;
	for (i=0; i<n; i++) {
		out[i] = sum[i][0];
		shift_left_f(sum[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2f01
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x2f10
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2eba
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: push_f
static void push_f(float *f, float val)
{
	f[0] = f[1];
	f[1] = f[2];
	f[2] = f[3];
	f[3] = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x8(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0xc(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: xscale_up_rgbx
static void xscale_up_rgbx(unsigned char *in, int width_in, float *out,
	float *coeff_buf, int *border_buf)
{
	int i, j;
	float smp[3][4] = {{0}};

	for (i=0; i<width_in; i++) {
		for (j=0; j<3; j++) {
			push_f(smp[j], s2l_map[in[j]]);
		}
		for (j=0; j<border_buf[i]; j++) {
			xscale_up_reduce_n(smp, out, coeff_buf, 3);
			out[3] = 0;
			out += 4;
			coeff_buf += 4;
		}
		in += 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1090
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x308a
movl $0x0, -0x30(%rbp)
cmpl $0x3, -0x30(%rbp)
jge 0x3014
movslq -0x30(%rbp), %rax
leaq -0x60(%rbp), %rdi
shlq $0x4, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x60b1(%rip), %rax      # 0x90b0
movss (%rax,%rcx,4), %xmm0
callq 0x2f30
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2fd5
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x3070
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x3, %ecx
callq 0x35c0
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rax)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x301b
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2fc2
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: xscale_up_rgb
static void xscale_up_rgb(unsigned char *in, int width_in, float *out,
	float *coeff_buf, int *border_buf)
{
	int i, j;
	float smp[3][4] = {{0}};

	for (i=0; i<width_in; i++) {
		for (j=0; j<3; j++) {
			push_f(smp[j], s2l_map[in[j]]);
		}
		for (j=0; j<border_buf[i]; j++) {
			xscale_up_reduce_n(smp, out, coeff_buf, 3);
			out += 3;
			coeff_buf += 4;
		}
		in += 3;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1090
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x317e
movl $0x0, -0x30(%rbp)
cmpl $0x3, -0x30(%rbp)
jge 0x3114
movslq -0x30(%rbp), %rax
leaq -0x60(%rbp), %rdi
shlq $0x4, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x5fb1(%rip), %rax      # 0x90b0
movss (%rax,%rcx,4), %xmm0
callq 0x2f30
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x30d5
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x3164
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x3, %ecx
callq 0x35c0
movq -0x18(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x311b
movq -0x8(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x8(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x30c2
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: xscale_up_g
static void xscale_up_g(unsigned char *in, int width_in, float *out,
	float *coeff_buf, int *border_buf)
{
	int i, j;
	float smp[4] = {0};

	for (i=0; i<width_in; i++) {
		push_f(smp, in[i] / 255.0f);
		for (j=0; j<border_buf[i]; j++) {
			out[0] = smp[0] * coeff_buf[0] +
				smp[1] * coeff_buf[1] +
				smp[2] * coeff_buf[2] +
				smp[3] * coeff_buf[3];
			out += 1;
			coeff_buf += 4;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3297
leaq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x2e8e(%rip), %xmm1     # 0x6078
divss %xmm1, %xmm0
callq 0x2f30
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x3287
movss -0x40(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss (%rax), %xmm2
movss -0x3c(%rbp), %xmm1
movq -0x20(%rbp), %rax
mulss 0x4(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x38(%rbp), %xmm1
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss -0x34(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss 0xc(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x31fa
jmp 0x3289
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x31c2
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: xscale_up_cmyk
static void xscale_up_cmyk(unsigned char *in, int width_in, float *out,
	float *coeff_buf, int *border_buf)
{
	int i, j;
	float smp[4][4] = {{0}};

	for (i=0; i<width_in; i++) {
		for (j=0; j<4; j++) {
			push_f(smp[j], in[j] / 255.0f);
		}
		for (j=0; j<border_buf[i]; j++) {
			xscale_up_reduce_n(smp, out, coeff_buf, 4);
			out += 4;
			coeff_buf += 4;
		}
		in += 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1090
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3390
movl $0x0, -0x30(%rbp)
cmpl $0x4, -0x30(%rbp)
jge 0x3326
movslq -0x30(%rbp), %rax
leaq -0x70(%rbp), %rdi
shlq $0x4, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x2d66(%rip), %xmm1     # 0x6078
divss %xmm1, %xmm0
callq 0x2f30
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x32e5
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x3376
leaq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x4, %ecx
callq 0x35c0
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x332d
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x32d2
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: xscale_up_rgba
static void xscale_up_rgba(unsigned char *in, int width_in, float *out,
	float *coeff_buf, int *border_buf)
{
	int i, j;
	float smp[4][4] = {{0}};

	for (i=0; i<width_in; i++) {
		push_f(smp[3], in[3] / 255.0f);
		for (j=0; j<3; j++) {
			push_f(smp[j], smp[3][3] * s2l_map[in[j]]);
		}
		for (j=0; j<border_buf[i]; j++) {
			xscale_up_reduce_n(smp, out, coeff_buf, 4);
			out += 4;
			coeff_buf += 4;
		}
		in += 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1090
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x34b8
leaq -0x70(%rbp), %rdi
addq $0x30, %rdi
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %eax
cvtsi2ss %eax, %xmm0
movss 0x2c7e(%rip), %xmm1     # 0x6078
divss %xmm1, %xmm0
callq 0x2f30
movl $0x0, -0x30(%rbp)
cmpl $0x3, -0x30(%rbp)
jge 0x344e
movslq -0x30(%rbp), %rax
leaq -0x70(%rbp), %rdi
shlq $0x4, %rax
addq %rax, %rdi
movss -0x34(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x5c77(%rip), %rax      # 0x90b0
mulss (%rax,%rcx,4), %xmm0
callq 0x2f30
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x340a
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x349e
leaq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x4, %ecx
callq 0x35c0
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3455
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x33d2
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: xscale_up_ga
static void xscale_up_ga(unsigned char *in, int width_in, float *out,
	float *coeff_buf, int *border_buf)
{
	int i, j;
	float smp[2][4] = {{0}};

	for (i=0; i<width_in; i++) {
		push_f(smp[1], in[1] / 255.0f);
		push_f(smp[0], smp[1][3] * i2f_map[in[0]]);
		for (j=0; j<border_buf[i]; j++) {
			xscale_up_reduce_n(smp, out, coeff_buf, 2);
			out += 2;
			coeff_buf += 4;
		}
		in += 2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1090
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x35b0
leaq -0x50(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
cvtsi2ss %eax, %xmm0
movss 0x2b5e(%rip), %xmm1     # 0x6078
divss %xmm1, %xmm0
callq 0x2f30
leaq -0x50(%rbp), %rdi
movss -0x34(%rbp), %xmm0
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xdf94(%rip), %rax      # 0x114d0
mulss (%rax,%rcx,4), %xmm0
callq 0x2f30
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x3596
leaq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x2, %ecx
callq 0x35c0
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x354d
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x34f2
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: xscale_up_reduce_n
static void xscale_up_reduce_n(float in[][4], float *out, float *coeffs,
	int cmp)
{
	int i;

	for (i=0; i<cmp; i++) {
		out[i] = in[i][0] * coeffs[0] +
			in[i][1] * coeffs[1] +
			in[i][2] * coeffs[2] +
			in[i][3] * coeffs[3];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x368b
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss (%rax), %xmm2
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss 0x4(%rax), %xmm1
movq -0x18(%rbp), %rax
mulss 0x4(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss 0x8(%rax), %xmm1
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss 0xc(%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x35da
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: yscale_out_nonlinear
static void yscale_out_nonlinear(float *sums, int sl_len, unsigned char *out)
{
	int i;

	for (i=0; i<sl_len; i++) {
		out[i] = clamp8(*sums);
		shift_left_f(sums);
		sums += 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x36ec
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
callq 0x3990
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x2f10
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x36aa
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: yscale_out_ga
static void yscale_out_ga(float *sums, int width, unsigned char *out)
{
	int i;
	float alpha;

	for (i=0; i<width; i++) {
		alpha = clampf(sums[4]);
		if (alpha != 0) {
			sums[0] /= alpha;
		}
		out[0] = clamp8(sums[0]);
		shift_left_f(sums);
		out[1] = f2i(alpha * 255.0f);
		shift_left_f(sums + 4);
		sums += 8;
		out += 2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x37cb
movq -0x8(%rbp), %rax
movss 0x10(%rax), %xmm0
callq 0x39e0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x374a
jp 0x374a
jmp 0x375f
movss -0x20(%rbp), %xmm1
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax)
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
callq 0x3990
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rdi
callq 0x2f10
movss 0x28f3(%rip), %xmm0     # 0x6078
mulss -0x20(%rbp), %xmm0
callq 0x39c0
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x2f10
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x371a
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: yscale_out_linear
static void yscale_out_linear(float *sums, int len, unsigned char *out)
{
	int i;

	for (i=0; i<len; i++) {
		out[i] = linear_sample_to_srgb(*sums);
		shift_left_f(sums);
		sums += 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x383c
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
callq 0x3a30
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x2f10
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x37fa
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: yscale_out_rgba
static void yscale_out_rgba(float *sums, int width, unsigned char *out)
{
	int i, j;
	float alpha;

	for (i=0; i<width; i++) {
		alpha = clampf(sums[12]);
		if (alpha != 0) {
			for (j=0; j<3; j++) {
				sums[j * 4] /= alpha;
			}
		}
		for (j=0; j<3; j++) {
			out[j] = linear_sample_to_srgb(clampf(sums[j * 4]));
			shift_left_f(sums + j * 4);
		}
		out[3] = round(alpha * 255.0f);
		shift_left_f(sums + 12);
		sums += 16;
		out += 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3987
movq -0x8(%rbp), %rax
movss 0x30(%rax), %xmm0
callq 0x39e0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x389a
jp 0x389a
jmp 0x38d4
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0x38d2
movss -0x24(%rbp), %xmm1
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x38a1
jmp 0x38d4
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0x392d
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
callq 0x39e0
callq 0x3a30
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %eax
shll $0x2, %eax
cltq
shlq $0x2, %rax
addq %rax, %rdi
callq 0x2f10
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x38db
movss -0x24(%rbp), %xmm0
movss 0x273e(%rip), %xmm1     # 0x6078
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1040
cvttsd2si %xmm0, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x2f10
movq -0x8(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x386a
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: clampf
static float clampf(float x)
{
	if (x > 1.0f) {
		return 1.0f;
	} else if (x < 0.0f) {
		return 0.0f;
	}
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
movss 0x2686(%rip), %xmm1     # 0x607c
ucomiss %xmm1, %xmm0
jbe 0x3a0a
movss 0x2679(%rip), %xmm0     # 0x607c
movss %xmm0, -0x4(%rbp)
jmp 0x3a29
xorps %xmm0, %xmm0
ucomiss -0x8(%rbp), %xmm0
jbe 0x3a1d
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x3a29
jmp 0x3a1f
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: yscale_up_g_cmyk
static void yscale_up_g_cmyk(float **in, int len, float *coeffs,
	unsigned char *out)
{
	int i;
	float sum;

	for (i=0; i<len; i++) {
		sum = coeffs[0] * in[0][i] +
			coeffs[1] * in[1][i] +
			coeffs[2] * in[2][i] +
			coeffs[3] * in[3][i];
		out[i] = clamp8(sum);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3b42
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
callq 0x3990
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3a8e
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: yscale_up_ga
static void yscale_up_ga(float **in, int len, float *coeffs,
	unsigned char *out)
{
	int i, j;
	float alpha, sums[2];

	for (i=0; i<len; i+=2) {
		for (j=0; j<2; j++) {
			sums[j] = coeffs[0] * in[0][i + j] +
				coeffs[1] * in[1][i + j] +
				coeffs[2] * in[2][i + j] +
				coeffs[3] * in[3][i + j];
		}
		alpha = clampf(sums[1]);
		if (alpha != 0) {
			sums[0] /= alpha;
		}
		out[i] = clamp8(sums[0]);
		out[i + 1] = f2i(alpha * 255.0f);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3cb1
movl $0x0, -0x28(%rbp)
cmpl $0x2, -0x28(%rbp)
jge 0x3c35
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
mulss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movslq -0x28(%rbp), %rax
movss %xmm0, -0x34(%rbp,%rax,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3b81
movss -0x30(%rbp), %xmm0
callq 0x39e0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3c55
jp 0x3c55
jmp 0x3c68
movss -0x2c(%rbp), %xmm1
movss -0x34(%rbp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x34(%rbp), %xmm0
callq 0x3990
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movss 0x23f1(%rip), %xmm0     # 0x6078
mulss -0x2c(%rbp), %xmm0
callq 0x39c0
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x24(%rbp)
jmp 0x3b6e
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: yscale_up_rgbx
static void yscale_up_rgbx(float **in, int len, float coeffs[4],
	unsigned char *out)
{
	int i, j;
	float sum;

	for (i=0; i<len; i+=4) {
		for (j=0; j<3; j++) {
			sum = coeffs[0] * in[0][i + j] +
				coeffs[1] * in[1][i + j] +
				coeffs[2] * in[2][i + j] +
				coeffs[3] * in[3][i + j];
			out[i + j] = linear_sample_to_srgb(sum);
		}
		out[i + 3] = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3ebb
movl $0x0, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0x3e9c
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
mulss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
callq 0x3a30
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3dd1
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x24(%rbp)
jmp 0x3dbe
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ender672[P]liboil/oil_resample.c
// Function: yscale_up_rgba
static void yscale_up_rgba(float **in, int len, float *coeffs,
	unsigned char *out)
{
	int i, j;
	float alpha, sums[4];

	for (i=0; i<len; i+=4) {
		for (j=0; j<4; j++) {
			sums[j] = coeffs[0] * in[0][i + j] +
				coeffs[1] * in[1][i + j] +
				coeffs[2] * in[2][i + j] +
				coeffs[3] * in[3][i + j];
		}
		alpha = clampf(sums[3]);
		for (j=0; j<3; j++) {
			if (alpha != 0 && alpha != 1.0f) {
				sums[j] /= alpha;
				sums[j] = clampf(sums[j]);
			}
			out[i + j] = linear_sample_to_srgb(sums[j]);
		}
		out[i + 3] = f2i(alpha * 255.0f);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x408f
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jge 0x3fb5
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
mulss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movslq -0x28(%rbp), %rax
movss %xmm0, -0x40(%rbp,%rax,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3f01
movss -0x34(%rbp), %xmm0
callq 0x39e0
movss %xmm0, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0x405d
movss -0x2c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3fe6
jp 0x3fe6
jmp 0x402e
movss -0x2c(%rbp), %xmm0
movss 0x2089(%rip), %xmm1     # 0x607c
ucomiss %xmm1, %xmm0
jne 0x3ffc
jp 0x3ffc
jmp 0x402e
movss -0x2c(%rbp), %xmm1
movslq -0x28(%rbp), %rax
movss -0x40(%rbp,%rax,4), %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0x40(%rbp,%rax,4)
movslq -0x28(%rbp), %rax
movss -0x40(%rbp,%rax,4), %xmm0
callq 0x39e0
movslq -0x28(%rbp), %rax
movss %xmm0, -0x40(%rbp,%rax,4)
movslq -0x28(%rbp), %rax
movss -0x40(%rbp,%rax,4), %xmm0
callq 0x3a30
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3fcb
movss 0x2013(%rip), %xmm0     # 0x6078
mulss -0x2c(%rbp), %xmm0
callq 0x39c0
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x24(%rbp)
jmp 0x3eee
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop