#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int return_downscaled_array_len(int, int const, int const);
int sin(long double);
int /*<<< orphan*/ upsample_component_line_lanczos(float *, float *, float *,
                                                   float *, int, int, int const,
                                                   int const, int);
void upsample_component_lanczos(unsigned char *carray, int width, int height,
                                const int xpos, const int ypos, const int xstep,
                                const int ystep) {
  float x_out_buff[width];
  float weight_x_out_buff[width];
  float x_in_buff[width];
  float y_out_buff[height];
  float weight_y_out_buff[height];
  float y_in_buff[height];
  int compressed_width;
  int compressed_height;
  int linecount;
  unsigned char *datastart;
  float incoming_data;
  int i;
  float x_contrib[(3 * 2 * xstep) + 1];
  float y_contrib[(3 * 2 * ystep) + 1];
  int x_contrib_size;
  int y_contrib_size;
  int x_neo_radius = 3 * xstep;
  int y_neo_radius = 3 * ystep;
  float x;
  x_contrib_size = (x_neo_radius * 2) + 1;
  for (i = 0; i < x_contrib_size; i++) {
    if (i != x_neo_radius) {
      x = ((float)(i - x_neo_radius) / (float)xstep);
      x_contrib[i] =
          (float)((3 * sin(3.1415926535897932384626433832795029L * (double)x) *
                   sin((3.1415926535897932384626433832795029L / 3) *
                       (double)x)) /
                  (3.1415926535897932384626433832795029L *
                   3.1415926535897932384626433832795029L * (double)x *
                   (double)x));
    }
  }
  x_contrib[x_neo_radius] = 1;
  y_contrib_size = (y_neo_radius * 2) + 1;
  for (i = 0; i < y_contrib_size; i++) {
    if (i != y_neo_radius) {
      x = ((float)(i - y_neo_radius) / (float)ystep);
      y_contrib[i] =
          (float)((3 * sin(3.1415926535897932384626433832795029L * (double)x) *
                   sin((3.1415926535897932384626433832795029L / 3) *
                       (double)x)) /
                  (3.1415926535897932384626433832795029L *
                   3.1415926535897932384626433832795029L * (double)x *
                   (double)x));
    }
  }
  y_contrib[y_neo_radius] = 1;
  compressed_width = return_downscaled_array_len(width, xpos, xstep);
  compressed_height = return_downscaled_array_len(height, ypos, ystep);
  if ((xstep != 1) || (xpos != 0)) {
    for (linecount = 0; linecount < compressed_height; linecount++) {
      datastart = carray + (linecount * width);
      for (i = 0; i < compressed_width; i++)
        *(x_in_buff + i) = (float)*(datastart + i);
      upsample_component_line_lanczos(x_in_buff, x_out_buff, weight_x_out_buff,
                                      x_contrib, x_contrib_size, width, xpos,
                                      xstep, compressed_width);
      for (i = 0; i < width; i++) {
        incoming_data = *(x_out_buff + i);
        if (incoming_data > 255)
          *(datastart + i) = 255;
        else if (incoming_data < 0)
          *(datastart + i) = 0;
        else
          *(datastart + i) = (unsigned char)incoming_data;
      }
    }
  }
  if ((ystep != 1) || (ypos != 0)) {
    for (linecount = 0; linecount < width; linecount++) {
      datastart = carray + linecount;
      for (i = 0; i < compressed_height; i++)
        *(y_in_buff + i) = (float)*(datastart + (width * i));
      upsample_component_line_lanczos(y_in_buff, y_out_buff, weight_y_out_buff,
                                      y_contrib, y_contrib_size, height, ypos,
                                      ystep, compressed_height);
      for (i = 0; i < height; i++) {
        incoming_data = *(y_out_buff + i);
        if (incoming_data > 255)
          *(datastart + (width * i)) = 255;
        else if (incoming_data < 0)
          *(datastart + (width * i)) = 0;
        else
          *(datastart + (width * i)) = (unsigned char)incoming_data;
      }
    }
  }
}


x86 assembly (clang, -O0):
<upsample_component_lanczos>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x28(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x120(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x30(%rbp)
mov    -0xc(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x118(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x38(%rbp)
mov    -0xc(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x110(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x108(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x100(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xf8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x58(%rbp)
mov    -0x1c(%rbp),%ecx
add    %ecx,%ecx
mov    %ecx,%eax
lea    (%rax,%rax,2),%eax
or     $0x1,%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xf0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x80(%rbp)
mov    0x10(%rbp),%ecx
add    %ecx,%ecx
mov    %ecx,%eax
lea    (%rax,%rax,2),%eax
or     $0x1,%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xe8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x88(%rbp)
imul   $0x3,-0x1c(%rbp),%eax
mov    %eax,-0x94(%rbp)
imul   $0x3,0x10(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x94(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jge    13d5 <upsample_component_lanczos+0x2a5>
mov    -0x78(%rbp),%eax
cmp    -0x94(%rbp),%eax
je     13c2 <upsample_component_lanczos+0x292>
mov    -0x78(%rbp),%eax
mov    -0x94(%rbp),%ecx
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
cvtsi2ssl -0x1c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
fldl   -0xc8(%rbp)
fldt   0xcfc(%rip)
fmulp  %st,%st(1)
sub    $0x10,%rsp
mov    %rsp,%rax
fstpt  (%rax)
call   1040 <sin@plt>
add    $0x10,%rsp
mov    %eax,-0x124(%rbp)
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
fldl   -0xd0(%rbp)
fldt   0xcd2(%rip)
fmulp  %st,%st(1)
sub    $0x10,%rsp
mov    %rsp,%rax
fstpt  (%rax)
call   1040 <sin@plt>
mov    -0x124(%rbp),%edx
add    $0x10,%rsp
mov    %eax,%ecx
mov    -0xf0(%rbp),%rax
imul   %ecx,%edx
mov    %edx,%ecx
lea    (%rcx,%rcx,2),%ecx
mov    %ecx,-0xc0(%rbp)
fildl  -0xc0(%rbp)
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
fldl   -0xd8(%rbp)
fldt   0xc8b(%rip)
fmul   %st(1),%st
fmulp  %st,%st(1)
fdivrp %st,%st(1)
fstps  -0xdc(%rbp)
movss  -0xdc(%rbp),%xmm0
ff
movslq -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    13c7 <upsample_component_lanczos+0x297>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    12b6 <upsample_component_lanczos+0x186>
mov    -0xf0(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  0xc15(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x98(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x90(%rbp),%eax
jge    1528 <upsample_component_lanczos+0x3f8>
mov    -0x78(%rbp),%eax
cmp    -0x98(%rbp),%eax
je     1515 <upsample_component_lanczos+0x3e5>
mov    -0x78(%rbp),%eax
mov    -0x98(%rbp),%ecx
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
cvtsi2ssl 0x10(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
fldl   -0xa8(%rbp)
fldt   0xba9(%rip)
fmulp  %st,%st(1)
sub    $0x10,%rsp
mov    %rsp,%rax
fstpt  (%rax)
call   1040 <sin@plt>
add    $0x10,%rsp
mov    %eax,-0x128(%rbp)
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
fldl   -0xb0(%rbp)
fldt   0xb7f(%rip)
fmulp  %st,%st(1)
sub    $0x10,%rsp
mov    %rsp,%rax
fstpt  (%rax)
call   1040 <sin@plt>
mov    -0x128(%rbp),%edx
add    $0x10,%rsp
mov    %eax,%ecx
mov    -0xe8(%rbp),%rax
imul   %ecx,%edx
mov    %edx,%ecx
lea    (%rcx,%rcx,2),%ecx
mov    %ecx,-0xa0(%rbp)
fildl  -0xa0(%rbp)
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
fldl   -0xb8(%rbp)
fldt   0xb38(%rip)
fmul   %st(1),%st
fmulp  %st,%st(1)
fdivrp %st,%st(1)
fstps  -0xbc(%rbp)
movss  -0xbc(%rbp),%xmm0
ff
movslq -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    151a <upsample_component_lanczos+0x3ea>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1409 <upsample_component_lanczos+0x2d9>
mov    -0xe8(%rbp),%rax
movslq -0x98(%rbp),%rcx
movss  0xac2(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x1c(%rbp),%edx
call   1030 <return_downscaled_array_len@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x10(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    0x10(%rbp),%edx
call   1030 <return_downscaled_array_len@plt>
mov    %eax,-0x60(%rbp)
cmpl   $0x1,-0x1c(%rbp)
jne    1579 <upsample_component_lanczos+0x449>
cmpl   $0x0,-0x14(%rbp)
je     16dd <upsample_component_lanczos+0x5ad>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    16d8 <upsample_component_lanczos+0x5a8>
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    15e2 <upsample_component_lanczos+0x4b2>
mov    -0x110(%rbp),%rax
mov    -0x70(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cvtsi2ss %ecx,%xmm0
movslq -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    15a8 <upsample_component_lanczos+0x478>
mov    -0xf0(%rbp),%rcx
mov    -0x118(%rbp),%rdx
mov    -0x120(%rbp),%rsi
mov    -0x110(%rbp),%rdi
mov    -0x8c(%rbp),%r8d
mov    -0xc(%rbp),%r9d
mov    -0x14(%rbp),%r11d
mov    -0x1c(%rbp),%r10d
mov    -0x5c(%rbp),%eax
sub    $0x20,%rsp
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1050 <upsample_component_line_lanczos@plt>
add    $0x20,%rsp
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16c5 <upsample_component_lanczos+0x595>
mov    -0x120(%rbp),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
movss  0x9a1(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    167d <upsample_component_lanczos+0x54d>
mov    -0x70(%rbp),%rax
movslq -0x78(%rbp),%rcx
movb   $0xff,(%rax,%rcx,1)
jmp    16b2 <upsample_component_lanczos+0x582>
xorps  %xmm0,%xmm0
ucomiss -0x74(%rbp),%xmm0
jbe    169b <upsample_component_lanczos+0x56b>
mov    -0x70(%rbp),%rax
movslq -0x78(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    16ad <upsample_component_lanczos+0x57d>
cvttss2si -0x74(%rbp),%eax
mov    %al,%dl
mov    -0x70(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    16b2 <upsample_component_lanczos+0x582>
jmp    16b7 <upsample_component_lanczos+0x587>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1635 <upsample_component_lanczos+0x505>
jmp    16ca <upsample_component_lanczos+0x59a>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1580 <upsample_component_lanczos+0x450>
jmp    16dd <upsample_component_lanczos+0x5ad>
cmpl   $0x1,0x10(%rbp)
jne    16f1 <upsample_component_lanczos+0x5c1>
cmpl   $0x0,-0x18(%rbp)
je     1869 <upsample_component_lanczos+0x739>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1864 <upsample_component_lanczos+0x734>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    175c <upsample_component_lanczos+0x62c>
mov    -0xf8(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    -0xc(%rbp),%edx
mov    -0x78(%rbp),%esi
imul   %esi,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
cvtsi2ss %ecx,%xmm0
movslq -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    171a <upsample_component_lanczos+0x5ea>
mov    -0xe8(%rbp),%rcx
mov    -0x100(%rbp),%rdx
mov    -0x108(%rbp),%rsi
mov    -0xf8(%rbp),%rdi
mov    -0x90(%rbp),%r8d
mov    -0x10(%rbp),%r9d
mov    -0x18(%rbp),%r11d
mov    0x10(%rbp),%r10d
mov    -0x60(%rbp),%eax
sub    $0x20,%rsp
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1050 <upsample_component_line_lanczos@plt>
add    $0x20,%rsp
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1851 <upsample_component_lanczos+0x721>
mov    -0x108(%rbp),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
movss  0x827(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    17fd <upsample_component_lanczos+0x6cd>
mov    -0x70(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x78(%rbp),%ecx
movslq %ecx,%rcx
movb   $0xff,(%rax,%rcx,1)
jmp    183e <upsample_component_lanczos+0x70e>
xorps  %xmm0,%xmm0
ucomiss -0x74(%rbp),%xmm0
jbe    1821 <upsample_component_lanczos+0x6f1>
mov    -0x70(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x78(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1839 <upsample_component_lanczos+0x709>
cvttss2si -0x74(%rbp),%eax
mov    %al,%dl
mov    -0x70(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x78(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    183e <upsample_component_lanczos+0x70e>
jmp    1843 <upsample_component_lanczos+0x713>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    17af <upsample_component_lanczos+0x67f>
jmp    1856 <upsample_component_lanczos+0x726>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    16f8 <upsample_component_lanczos+0x5c8>
jmp    1869 <upsample_component_lanczos+0x739>
mov    -0x28(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<upsample_component_lanczos>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %r8,-0xc0(%rbp)
mov    %rcx,-0x100(%rbp)
mov    %rdi,-0x80(%rbp)
mov    0x10(%rbp),%ecx
mov    %esi,-0x30(%rbp)
mov    %esi,%r15d
mov    %rsp,%rsi
lea    0xf(,%r15,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rsi
mov    %rsi,-0xf8(%rbp)
mov    %rsi,%rsp
mov    %rsp,%rsi
sub    %rax,%rsi
mov    %rsi,-0x148(%rbp)
mov    %rsi,%rsp
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
mov    %edx,-0x54(%rbp)
mov    %edx,%eax
mov    %rsp,%rdx
mov    %rax,-0xf0(%rbp)
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rdx
mov    %rdx,-0x108(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rdx
sub    %rax,%rdx
mov    %rdx,-0x150(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rdx
sub    %rax,%rdx
mov    %rdx,-0xd8(%rbp)
mov    %rdx,%rsp
lea    (%r9,%r9,1),%eax
lea    (%rax,%rax,2),%edx
or     $0x1,%edx
lea    0xf(,%rdx,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rsi
sub    %rax,%rsi
mov    %rsi,-0x68(%rbp)
mov    %rsi,%rsp
lea    (%rcx,%rcx,1),%eax
lea    (%rax,%rax,2),%eax
or     $0x1,%eax
mov    %rax,-0xd0(%rbp)
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0xc8(%rbp)
mov    %rcx,%rsp
mov    %r9,-0x60(%rbp)
lea    (%r9,%r9,2),%eax
mov    %eax,-0x78(%rbp)
mov    %rdx,-0x88(%rbp)
test   %edx,%edx
jle    132d <upsample_component_lanczos+0x1fd>
mov    -0x60(%rbp),%rax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x78(%rbp),%r14d
lea    (%rax,%rax,2),%eax
neg    %eax
mov    %rax,-0x38(%rbp)
xor    %r13d,%r13d
fldt   0xd98(%rip)
fstpt  -0xb8(%rbp)
fldt   0xd9c(%rip)
fstpt  -0xa8(%rbp)
fldt   0xda0(%rip)
fstpt  -0x98(%rbp)
jmp    12a1 <upsample_component_lanczos+0x171>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    %r13,-0x88(%rbp)
je     132d <upsample_component_lanczos+0x1fd>
cmp    %r13,%r14
je     1290 <upsample_component_lanczos+0x160>
mov    -0x38(%rbp),%rax
add    %r13d,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
divss  -0x40(%rbp),%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
flds   -0xe4(%rbp)
fld    %st(0)
fstpt  -0x50(%rbp)
fldt   -0xb8(%rbp)
fmulp  %st,%st(1)
sub    $0x10,%rsp
fstpt  (%rsp)
call   1040 <sin@plt>
add    $0x10,%rsp
mov    %eax,%ebx
fldt   -0xa8(%rbp)
fldt   -0x50(%rbp)
fmulp  %st,%st(1)
sub    $0x10,%rsp
fstpt  (%rsp)
call   1040 <sin@plt>
add    $0x10,%rsp
imul   %ebx,%eax
lea    (%rax,%rax,2),%eax
mov    %eax,-0xe8(%rbp)
fldt   -0x98(%rbp)
fldt   -0x50(%rbp)
fmul   %st,%st(1)
fmulp  %st,%st(1)
fidivrl -0xe8(%rbp)
mov    -0x68(%rbp),%rax
fstps  (%rax,%r13,4)
jmp    1290 <upsample_component_lanczos+0x160>
mov    0x10(%rbp),%eax
lea    (%rax,%rax,2),%eax
mov    %eax,-0x70(%rbp)
movslq -0x78(%rbp),%rax
mov    -0x68(%rbp),%rcx
movl   $0x3f800000,(%rcx,%rax,4)
cmpl   $0x0,-0xd0(%rbp)
jle    1440 <upsample_component_lanczos+0x310>
mov    0x10(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x70(%rbp),%r14d
lea    (%rax,%rax,2),%eax
neg    %eax
mov    %rax,-0x38(%rbp)
xor    %r13d,%r13d
fldt   0xc89(%rip)
fstpt  -0xb8(%rbp)
fldt   0xc8d(%rip)
fstpt  -0xa8(%rbp)
fldt   0xc91(%rip)
fstpt  -0x98(%rbp)
jmp    13b1 <upsample_component_lanczos+0x281>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    %r13,-0xd0(%rbp)
je     1440 <upsample_component_lanczos+0x310>
cmp    %r13,%r14
je     13a0 <upsample_component_lanczos+0x270>
mov    -0x38(%rbp),%rax
add    %r13d,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
divss  -0x40(%rbp),%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
flds   -0xdc(%rbp)
fld    %st(0)
fstpt  -0x50(%rbp)
fldt   -0xb8(%rbp)
fmulp  %st,%st(1)
sub    $0x10,%rsp
fstpt  (%rsp)
call   1040 <sin@plt>
add    $0x10,%rsp
mov    %eax,%ebx
fldt   -0xa8(%rbp)
fldt   -0x50(%rbp)
fmulp  %st,%st(1)
sub    $0x10,%rsp
fstpt  (%rsp)
call   1040 <sin@plt>
add    $0x10,%rsp
imul   %ebx,%eax
lea    (%rax,%rax,2),%eax
mov    %eax,-0xe0(%rbp)
fldt   -0x98(%rbp)
fldt   -0x50(%rbp)
fmul   %st,%st(1)
fmulp  %st,%st(1)
fidivrl -0xe0(%rbp)
mov    -0xc8(%rbp),%rax
fstps  (%rax,%r13,4)
jmp    13a0 <upsample_component_lanczos+0x270>
movslq -0x70(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movl   $0x3f800000,(%rcx,%rax,4)
mov    -0x30(%rbp),%edi
mov    -0x100(%rbp),%r13
mov    %r13d,%esi
mov    -0x60(%rbp),%rbx
mov    %ebx,%edx
call   1030 <return_downscaled_array_len@plt>
mov    %eax,%r14d
mov    -0x54(%rbp),%edi
mov    -0xc0(%rbp),%rsi
mov    0x10(%rbp),%edx
call   1030 <return_downscaled_array_len@plt>
mov    %ebx,%ecx
xor    $0x1,%ecx
or     %r13d,%ecx
mov    %rax,-0x50(%rbp)
mov    %eax,%r8d
mov    -0xf8(%rbp),%rsi
je     1871 <upsample_component_lanczos+0x741>
cmpl   $0x0,-0x50(%rbp)
jle    1871 <upsample_component_lanczos+0x741>
mov    %r14,%r10
movslq -0x30(%rbp),%rax
mov    %r10d,%edx
mov    %edx,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,-0x70(%rbp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x140(%rbp)
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,-0x130(%rbp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x128(%rbp)
mov    %rcx,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %rdi,%rcx
mov    %rdi,-0x138(%rbp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,-0x118(%rbp)
mov    %rbx,%rcx
mov    %rbx,-0x120(%rbp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,-0x110(%rbp)
mov    -0x80(%rbp),%r13
lea    0xc(%r13),%rbx
xor    %ecx,%ecx
pxor   %xmm4,%xmm4
mov    %r8,-0x40(%rbp)
mov    %r14,-0xa8(%rbp)
mov    %rax,-0x98(%rbp)
mov    %rdx,-0x78(%rbp)
mov    -0x30(%rbp),%r14d
jmp    1579 <upsample_component_lanczos+0x449>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x38(%rbp),%rcx
add    $0x1,%rcx
mov    -0x98(%rbp),%rax
add    %rax,%rbx
add    %rax,%r13
cmp    %r8,%rcx
mov    -0xa8(%rbp),%r10
mov    -0x78(%rbp),%rdx
je     1871 <upsample_component_lanczos+0x741>
mov    %rcx,-0x38(%rbp)
mov    %rcx,%rdi
imul   %rax,%rdi
add    -0x80(%rbp),%rdi
test   %r10d,%r10d
jle    168c <upsample_component_lanczos+0x55c>
cmp    $0x8,%r10d
jae    15a0 <upsample_component_lanczos+0x470>
xor    %eax,%eax
jmp    1670 <upsample_component_lanczos+0x540>
xchg   %ax,%ax
cmpq   $0x0,-0x140(%rbp)
je     184c <upsample_component_lanczos+0x71c>
mov    -0x118(%rbp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movd   -0xc(%rbx,%rax,1),%xmm0
movd   -0x8(%rbx,%rax,1),%xmm1
punpcklbw %xmm4,%xmm0
punpcklwd %xmm4,%xmm0
cvtdq2ps %xmm0,%xmm0
punpcklbw %xmm4,%xmm1
punpcklwd %xmm4,%xmm1
cvtdq2ps %xmm1,%xmm1
movaps %xmm0,(%r12,%rax,4)
movaps %xmm1,0x10(%r12,%rax,4)
movd   -0x4(%rbx,%rax,1),%xmm0
movd   (%rbx,%rax,1),%xmm1
punpcklbw %xmm4,%xmm0
punpcklwd %xmm4,%xmm0
cvtdq2ps %xmm0,%xmm0
punpcklbw %xmm4,%xmm1
punpcklwd %xmm4,%xmm1
cvtdq2ps %xmm1,%xmm1
movaps %xmm0,0x20(%r12,%rax,4)
movaps %xmm1,0x30(%r12,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    15c0 <upsample_component_lanczos+0x490>
testb  $0x1,-0x138(%rbp)
je     1659 <upsample_component_lanczos+0x529>
movd   (%rdi,%rax,1),%xmm0
movd   0x4(%rdi,%rax,1),%xmm1
punpcklbw %xmm4,%xmm0
punpcklwd %xmm4,%xmm0
cvtdq2ps %xmm0,%xmm0
punpcklbw %xmm4,%xmm1
punpcklwd %xmm4,%xmm1
cvtdq2ps %xmm1,%xmm1
movaps %xmm0,(%r12,%rax,4)
movaps %xmm1,0x10(%r12,%rax,4)
mov    -0x70(%rbp),%rcx
mov    %rcx,%rax
cmp    %rdx,%rcx
je     168c <upsample_component_lanczos+0x55c>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x0(%r13,%rax,1),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
movss  %xmm0,(%r12,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1670 <upsample_component_lanczos+0x540>
mov    %rdi,-0xb8(%rbp)
sub    $0x8,%rsp
mov    %r12,%rdi
mov    -0x148(%rbp),%rdx
mov    -0x68(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    %r14d,%r9d
push   %r10
push   -0x60(%rbp)
push   -0x100(%rbp)
call   1050 <upsample_component_line_lanczos@plt>
movaps 0x97a(%rip),%xmm6
movaps 0x963(%rip),%xmm7
xorps  %xmm8,%xmm8
pxor   %xmm4,%xmm4
mov    -0xf8(%rbp),%rsi
add    $0x20,%rsp
test   %r14d,%r14d
mov    -0x40(%rbp),%r8
movss  0x961(%rip),%xmm5
jle    1550 <upsample_component_lanczos+0x420>
cmpl   $0x4,-0x30(%rbp)
jae    1710 <upsample_component_lanczos+0x5e0>
xor    %eax,%eax
jmp    1836 <upsample_component_lanczos+0x706>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpq   $0x0,-0x128(%rbp)
je     1860 <upsample_component_lanczos+0x730>
mov    -0x110(%rbp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movaps (%rsi,%rax,4),%xmm0
movaps %xmm7,%xmm1
cmpltps %xmm0,%xmm1
movaps %xmm7,%xmm2
cmpleps %xmm0,%xmm2
movaps %xmm7,%xmm3
andps  %xmm2,%xmm3
andnps %xmm0,%xmm2
cmpnltps %xmm4,%xmm0
orps   %xmm1,%xmm0
orps   %xmm3,%xmm2
cvttps2dq %xmm2,%xmm1
andps  %xmm6,%xmm0
andps  %xmm1,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
movd   %xmm0,0x0(%r13,%rax,1)
movaps 0x10(%rsi,%rax,4),%xmm0
movaps %xmm7,%xmm1
cmpltps %xmm0,%xmm1
movaps %xmm7,%xmm2
cmpleps %xmm0,%xmm2
movaps %xmm7,%xmm3
andps  %xmm2,%xmm3
andnps %xmm0,%xmm2
cmpnltps %xmm4,%xmm0
orps   %xmm1,%xmm0
orps   %xmm3,%xmm2
cvttps2dq %xmm2,%xmm1
andps  %xmm6,%xmm0
andps  %xmm1,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
movd   %xmm0,0x4(%r13,%rax,1)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1730 <upsample_component_lanczos+0x600>
testb  $0x1,-0x120(%rbp)
je     1807 <upsample_component_lanczos+0x6d7>
movaps (%rsi,%rax,4),%xmm0
movaps %xmm7,%xmm1
cmpltps %xmm0,%xmm1
movaps %xmm7,%xmm2
cmpleps %xmm0,%xmm2
movaps %xmm7,%xmm3
andps  %xmm2,%xmm3
andnps %xmm0,%xmm2
cmpnltps %xmm4,%xmm0
orps   %xmm1,%xmm0
orps   %xmm3,%xmm2
cvttps2dq %xmm2,%xmm1
andps  %xmm0,%xmm1
andps  %xmm6,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
mov    -0xb8(%rbp),%rcx
movd   %xmm1,(%rcx,%rax,1)
mov    -0x130(%rbp),%rcx
mov    %rcx,%rax
cmp    %r15,%rcx
jne    1836 <upsample_component_lanczos+0x706>
jmp    1550 <upsample_component_lanczos+0x420>
nopl   0x0(%rax,%rax,1)
cvttss2si %xmm0,%ecx
mov    %cl,0x0(%r13,%rax,1)
add    $0x1,%rax
cmp    %rax,%r15
je     1550 <upsample_component_lanczos+0x420>
movss  (%rsi,%rax,4),%xmm0
mov    $0xff,%cl
ucomiss %xmm5,%xmm0
ja     1824 <upsample_component_lanczos+0x6f4>
ucomiss %xmm0,%xmm8
jbe    1820 <upsample_component_lanczos+0x6f0>
xor    %ecx,%ecx
jmp    1824 <upsample_component_lanczos+0x6f4>
xor    %eax,%eax
testb  $0x1,-0x138(%rbp)
jne    162d <upsample_component_lanczos+0x4fd>
jmp    1659 <upsample_component_lanczos+0x529>
xor    %eax,%eax
testb  $0x1,-0x120(%rbp)
jne    17c4 <upsample_component_lanczos+0x694>
jmp    1807 <upsample_component_lanczos+0x6d7>
mov    0x10(%rbp),%eax
xor    $0x1,%eax
or     -0xc0(%rbp),%eax
mov    -0x108(%rbp),%rsi
je     1adb <upsample_component_lanczos+0x9ab>
cmpl   $0x0,-0x30(%rbp)
jle    1adb <upsample_component_lanczos+0x9ab>
lea    -0x1(%r8),%rax
mov    %rax,-0x68(%rbp)
mov    %r8d,%ebx
and    $0x3,%ebx
and    $0xfffffffc,%r8d
mov    -0xf0(%rbp),%rax
mov    %eax,%r9d
and    $0xfffffffe,%r9d
lea    0x0(,%r15,4),%r10
lea    (%r15,%r15,2),%r13
lea    (%r15,%r15,1),%rax
mov    %rax,-0x60(%rbp)
xor    %r14d,%r14d
mov    -0x80(%rbp),%r12
mov    %rbx,-0x30(%rbp)
mov    %r8,-0x40(%rbp)
jmp    18f9 <upsample_component_lanczos+0x7c9>
cvttss2si %xmm0,%edx
imul   %r15,%rax
mov    %dl,(%rcx,%rax,1)
add    $0x1,%r14
add    $0x1,%r12
cmp    %r15,%r14
mov    -0x30(%rbp),%rbx
je     1adb <upsample_component_lanczos+0x9ab>
mov    %r14,-0x88(%rbp)
cmpl   $0x0,-0x50(%rbp)
jle    19cb <upsample_component_lanczos+0x89b>
cmpq   $0x3,-0x68(%rbp)
jae    1920 <upsample_component_lanczos+0x7f0>
xor    %eax,%eax
jmp    1988 <upsample_component_lanczos+0x858>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r12,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rcx),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mov    -0xd8(%rbp),%rdi
movss  %xmm0,(%rdi,%rax,4)
movzbl (%rcx,%r15,1),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
movss  %xmm0,0x4(%rdi,%rax,4)
movzbl (%rcx,%r15,2),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
movss  %xmm0,0x8(%rdi,%rax,4)
movzbl (%rcx,%r13,1),%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
movss  %xmm0,0xc(%rdi,%rax,4)
add    $0x4,%rax
add    %r10,%rcx
cmp    %rax,%r8
jne    1930 <upsample_component_lanczos+0x800>
test   %rbx,%rbx
je     19cb <upsample_component_lanczos+0x89b>
mov    -0xd8(%rbp),%rcx
lea    (%rcx,%rax,4),%rcx
imul   %r15,%rax
add    %r12,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rax),%edi
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
movss  %xmm0,(%rcx,%rdx,4)
add    $0x1,%rdx
add    %r15,%rax
cmp    %rdx,%rbx
jne    19b0 <upsample_component_lanczos+0x880>
sub    $0x8,%rsp
mov    -0xd8(%rbp),%rdi
mov    -0x150(%rbp),%rdx
mov    -0xc8(%rbp),%rcx
mov    -0xd0(%rbp),%r8
mov    %r12,-0x38(%rbp)
mov    -0x54(%rbp),%r12d
mov    %r9,%rbx
mov    %r12d,%r9d
push   -0x50(%rbp)
mov    0x10(%rbp),%eax
push   %rax
push   -0xc0(%rbp)
mov    %r10,%r14
call   1050 <upsample_component_line_lanczos@plt>
xorps  %xmm2,%xmm2
mov    %r14,%r10
mov    %rbx,%r9
mov    -0x40(%rbp),%r8
add    $0x20,%rsp
test   %r12d,%r12d
mov    -0x38(%rbp),%r12
mov    -0x108(%rbp),%rsi
mov    -0x88(%rbp),%r14
movss  0x614(%rip),%xmm1
jle    18e4 <upsample_component_lanczos+0x7b4>
cmpl   $0x1,-0x54(%rbp)
jne    1a80 <upsample_component_lanczos+0x950>
xor    %eax,%eax
testb  $0x1,-0xf0(%rbp)
je     18e4 <upsample_component_lanczos+0x7b4>
mov    -0x80(%rbp),%rcx
add    %r14,%rcx
movss  (%rsi,%rax,4),%xmm0
mov    $0xff,%dl
ucomiss %xmm1,%xmm0
ja     18dd <upsample_component_lanczos+0x7ad>
ucomiss %xmm0,%xmm2
jbe    18d9 <upsample_component_lanczos+0x7a9>
xor    %edx,%edx
jmp    18dd <upsample_component_lanczos+0x7ad>
xchg   %ax,%ax
mov    %r12,%rcx
xor    %eax,%eax
mov    -0x60(%rbp),%rbx
jmp    1aa4 <upsample_component_lanczos+0x974>
nopl   0x0(%rax,%rax,1)
cvttss2si %xmm0,%edx
mov    %dl,(%rcx,%r15,1)
add    $0x2,%rax
add    %rbx,%rcx
cmp    %rax,%r9
je     1a4a <upsample_component_lanczos+0x91a>
movss  (%rsi,%rax,4),%xmm0
mov    $0xff,%dl
ucomiss %xmm1,%xmm0
mov    $0xff,%dil
ja     1ac4 <upsample_component_lanczos+0x994>
ucomiss %xmm0,%xmm2
jbe    1ac0 <upsample_component_lanczos+0x990>
xor    %edi,%edi
jmp    1ac4 <upsample_component_lanczos+0x994>
nopl   0x0(%rax)
cvttss2si %xmm0,%edi
mov    %dil,(%rcx)
movss  0x4(%rsi,%rax,4),%xmm0
ucomiss %xmm1,%xmm0
ja     1a94 <upsample_component_lanczos+0x964>
ucomiss %xmm0,%xmm2
jbe    1a90 <upsample_component_lanczos+0x960>
xor    %edx,%edx
jmp    1a94 <upsample_component_lanczos+0x964>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @upsample_component_lanczos(i8* %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6) {
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i8*
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca i64
%21 = alloca i64
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i8*
%26 = alloca float
%27 = alloca i32
%28 = alloca i64
%29 = alloca i64
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca float
store i8* %0, i8** %8
store i32 %1, i32* %9
store i32 %2, i32* %10
store i32 %3, i32* %11
store i32 %4, i32* %12
store i32 %5, i32* %13
store i32 %6, i32* %14
%35 = load i32, i32* %9
%36 = zext i32 %35 to i64
%37 = call i8* @llvm.stacksave()
store i8* %37, i8** %15
%38 = alloca float, i64 %36
store i64 %36, i64* %16
%39 = load i32, i32* %9
%40 = zext i32 %39 to i64
%41 = alloca float, i64 %40
store i64 %40, i64* %17
%42 = load i32, i32* %9
%43 = zext i32 %42 to i64
%44 = alloca float, i64 %43
store i64 %43, i64* %18
%45 = load i32, i32* %10
%46 = zext i32 %45 to i64
%47 = alloca float, i64 %46
store i64 %46, i64* %19
%48 = load i32, i32* %10
%49 = zext i32 %48 to i64
%50 = alloca float, i64 %49
store i64 %49, i64* %20
%51 = load i32, i32* %10
%52 = zext i32 %51 to i64
%53 = alloca float, i64 %52
store i64 %52, i64* %21
%54 = load i32, i32* %13
%55 = mul nsw i32 6, %54
%56 = add nsw i32 %55, 1
%57 = zext i32 %56 to i64
%58 = alloca float, i64 %57
store i64 %57, i64* %28
%59 = load i32, i32* %14
%60 = mul nsw i32 6, %59
%61 = add nsw i32 %60, 1
%62 = zext i32 %61 to i64
%63 = alloca float, i64 %62
store i64 %62, i64* %29
%64 = load i32, i32* %13
%65 = mul nsw i32 3, %64
store i32 %65, i32* %32
%66 = load i32, i32* %14
%67 = mul nsw i32 3, %66
store i32 %67, i32* %33
%68 = load i32, i32* %32
%69 = mul nsw i32 %68, 2
%70 = add nsw i32 %69, 1
store i32 %70, i32* %30
store i32 0, i32* %27
br label %71
71: ; preds = %114, %7
%72 = load i32, i32* %27
%73 = load i32, i32* %30
%74 = icmp slt i32 %72, %73
br i1 %74, label %75, label %117
75: ; preds = %71
%76 = load i32, i32* %27
%77 = load i32, i32* %32
%78 = icmp ne i32 %76, %77
br i1 %78, label %79, label %113
79: ; preds = %75
%80 = load i32, i32* %27
%81 = load i32, i32* %32
%82 = sub nsw i32 %80, %81
%83 = sitofp i32 %82 to float
%84 = load i32, i32* %13
%85 = sitofp i32 %84 to float
%86 = fdiv float %83, %85
store float %86, float* %34
%87 = load float, float* %34
%88 = fpext float %87 to double
%89 = fpext double %88 to x86_fp80
%90 = fmul x86_fp80 0xK4000C90FDAA22168C235, %89
%91 = call i32 @sin(x86_fp80 %90)
%92 = mul nsw i32 3, %91
%93 = load float, float* %34
%94 = fpext float %93 to double
%95 = fpext double %94 to x86_fp80
%96 = fmul x86_fp80 0xK3FFF860A91C16B9B2C23, %95
%97 = call i32 @sin(x86_fp80 %96)
%98 = mul nsw i32 %92, %97
%99 = sitofp i32 %98 to x86_fp80
%100 = load float, float* %34
%101 = fpext float %100 to double
%102 = fpext double %101 to x86_fp80
%103 = fmul x86_fp80 0xK40029DE9E64DF22EF2D3, %102
%104 = load float, float* %34
%105 = fpext float %104 to double
%106 = fpext double %105 to x86_fp80
%107 = fmul x86_fp80 %103, %106
%108 = fdiv x86_fp80 %99, %107
%109 = fptrunc x86_fp80 %108 to float
%110 = load i32, i32* %27
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds float, float* %58, i64 %111
store float %109, float* %112
br label %113
113: ; preds = %79, %75
br label %114
114: ; preds = %113
%115 = load i32, i32* %27
%116 = add nsw i32 %115, 1
store i32 %116, i32* %27
br label %71
117: ; preds = %71
%118 = load i32, i32* %32
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds float, float* %58, i64 %119
store float 1.000000e+00, float* %120
%121 = load i32, i32* %33
%122 = mul nsw i32 %121, 2
%123 = add nsw i32 %122, 1
store i32 %123, i32* %31
store i32 0, i32* %27
br label %124
124: ; preds = %167, %117
%125 = load i32, i32* %27
%126 = load i32, i32* %31
%127 = icmp slt i32 %125, %126
br i1 %127, label %128, label %170
128: ; preds = %124
%129 = load i32, i32* %27
%130 = load i32, i32* %33
%131 = icmp ne i32 %129, %130
br i1 %131, label %132, label %166
132: ; preds = %128
%133 = load i32, i32* %27
%134 = load i32, i32* %33
%135 = sub nsw i32 %133, %134
%136 = sitofp i32 %135 to float
%137 = load i32, i32* %14
%138 = sitofp i32 %137 to float
%139 = fdiv float %136, %138
store float %139, float* %34
%140 = load float, float* %34
%141 = fpext float %140 to double
%142 = fpext double %141 to x86_fp80
%143 = fmul x86_fp80 0xK4000C90FDAA22168C235, %142
%144 = call i32 @sin(x86_fp80 %143)
%145 = mul nsw i32 3, %144
%146 = load float, float* %34
%147 = fpext float %146 to double
%148 = fpext double %147 to x86_fp80
%149 = fmul x86_fp80 0xK3FFF860A91C16B9B2C23, %148
%150 = call i32 @sin(x86_fp80 %149)
%151 = mul nsw i32 %145, %150
%152 = sitofp i32 %151 to x86_fp80
%153 = load float, float* %34
%154 = fpext float %153 to double
%155 = fpext double %154 to x86_fp80
%156 = fmul x86_fp80 0xK40029DE9E64DF22EF2D3, %155
%157 = load float, float* %34
%158 = fpext float %157 to double
%159 = fpext double %158 to x86_fp80
%160 = fmul x86_fp80 %156, %159
%161 = fdiv x86_fp80 %152, %160
%162 = fptrunc x86_fp80 %161 to float
%163 = load i32, i32* %27
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds float, float* %63, i64 %164
store float %162, float* %165
br label %166
166: ; preds = %132, %128
br label %167
167: ; preds = %166
%168 = load i32, i32* %27
%169 = add nsw i32 %168, 1
store i32 %169, i32* %27
br label %124
170: ; preds = %124
%171 = load i32, i32* %33
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds float, float* %63, i64 %172
store float 1.000000e+00, float* %173
%174 = load i32, i32* %9
%175 = load i32, i32* %11
%176 = load i32, i32* %13
%177 = call i32 @return_downscaled_array_len(i32 %174, i32 %175, i32 %176)
store i32 %177, i32* %22
%178 = load i32, i32* %10
%179 = load i32, i32* %12
%180 = load i32, i32* %14
%181 = call i32 @return_downscaled_array_len(i32 %178, i32 %179, i32 %180)
store i32 %181, i32* %23
%182 = load i32, i32* %13
%183 = icmp ne i32 %182, 1
br i1 %183, label %187, label %184
184: ; preds = %170
%185 = load i32, i32* %11
%186 = icmp ne i32 %185, 0
br i1 %186, label %187, label %264
187: ; preds = %184, %170
store i32 0, i32* %24
br label %188
188: ; preds = %260, %187
%189 = load i32, i32* %24
%190 = load i32, i32* %23
%191 = icmp slt i32 %189, %190
br i1 %191, label %192, label %263
192: ; preds = %188
%193 = load i8*, i8** %8
%194 = load i32, i32* %24
%195 = load i32, i32* %9
%196 = mul nsw i32 %194, %195
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds i8, i8* %193, i64 %197
store i8* %198, i8** %25
store i32 0, i32* %27
br label %199
199: ; preds = %213, %192
%200 = load i32, i32* %27
%201 = load i32, i32* %22
%202 = icmp slt i32 %200, %201
br i1 %202, label %203, label %216
203: ; preds = %199
%204 = load i8*, i8** %25
%205 = load i32, i32* %27
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i8, i8* %204, i64 %206
%208 = load i8, i8* %207
%209 = uitofp i8 %208 to float
%210 = load i32, i32* %27
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds float, float* %44, i64 %211
store float %209, float* %212
br label %213
213: ; preds = %203
%214 = load i32, i32* %27
%215 = add nsw i32 %214, 1
store i32 %215, i32* %27
br label %199
216: ; preds = %199
%217 = load i32, i32* %30
%218 = load i32, i32* %9
%219 = load i32, i32* %11
%220 = load i32, i32* %13
%221 = load i32, i32* %22
%222 = call i32 @upsample_component_line_lanczos(float* %44, float* %38, float* %41, float* %58, i32 %217, i32 %218, i32 %219, i32 %220, i32 %221)
store i32 0, i32* %27
br label %223
223: ; preds = %256, %216
%224 = load i32, i32* %27
%225 = load i32, i32* %9
%226 = icmp slt i32 %224, %225
br i1 %226, label %227, label %259
227: ; preds = %223
%228 = load i32, i32* %27
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds float, float* %38, i64 %229
%231 = load float, float* %230
store float %231, float* %26
%232 = load float, float* %26
%233 = fcmp ogt float %232, 2.550000e+02
br i1 %233, label %234, label %239
234: ; preds = %227
%235 = load i8*, i8** %25
%236 = load i32, i32* %27
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds i8, i8* %235, i64 %237
store i8 -1, i8* %238
br label %255
239: ; preds = %227
%240 = load float, float* %26
%241 = fcmp olt float %240, 0.000000e+00
br i1 %241, label %242, label %247
242: ; preds = %239
%243 = load i8*, i8** %25
%244 = load i32, i32* %27
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds i8, i8* %243, i64 %245
store i8 0, i8* %246
br label %254
247: ; preds = %239
%248 = load float, float* %26
%249 = fptoui float %248 to i8
%250 = load i8*, i8** %25
%251 = load i32, i32* %27
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds i8, i8* %250, i64 %252
store i8 %249, i8* %253
br label %254
254: ; preds = %247, %242
br label %255
255: ; preds = %254, %234
br label %256
256: ; preds = %255
%257 = load i32, i32* %27
%258 = add nsw i32 %257, 1
store i32 %258, i32* %27
br label %223
259: ; preds = %223
br label %260
260: ; preds = %259
%261 = load i32, i32* %24
%262 = add nsw i32 %261, 1
store i32 %262, i32* %24
br label %188
263: ; preds = %188
br label %264
264: ; preds = %263, %184
%265 = load i32, i32* %14
%266 = icmp ne i32 %265, 1
br i1 %266, label %270, label %267
267: ; preds = %264
%268 = load i32, i32* %12
%269 = icmp ne i32 %268, 0
br i1 %269, label %270, label %353
270: ; preds = %267, %264
store i32 0, i32* %24
br label %271
271: ; preds = %349, %270
%272 = load i32, i32* %24
%273 = load i32, i32* %9
%274 = icmp slt i32 %272, %273
br i1 %274, label %275, label %352
275: ; preds = %271
%276 = load i8*, i8** %8
%277 = load i32, i32* %24
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds i8, i8* %276, i64 %278
store i8* %279, i8** %25
store i32 0, i32* %27
br label %280
280: ; preds = %296, %275
%281 = load i32, i32* %27
%282 = load i32, i32* %23
%283 = icmp slt i32 %281, %282
br i1 %283, label %284, label %299
284: ; preds = %280
%285 = load i8*, i8** %25
%286 = load i32, i32* %9
%287 = load i32, i32* %27
%288 = mul nsw i32 %286, %287
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds i8, i8* %285, i64 %289
%291 = load i8, i8* %290
%292 = uitofp i8 %291 to float
%293 = load i32, i32* %27
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds float, float* %53, i64 %294
store float %292, float* %295
br label %296
296: ; preds = %284
%297 = load i32, i32* %27
%298 = add nsw i32 %297, 1
store i32 %298, i32* %27
br label %280
299: ; preds = %280
%300 = load i32, i32* %31
%301 = load i32, i32* %10
%302 = load i32, i32* %12
%303 = load i32, i32* %14
%304 = load i32, i32* %23
%305 = call i32 @upsample_component_line_lanczos(float* %53, float* %47, float* %50, float* %63, i32 %300, i32 %301, i32 %302, i32 %303, i32 %304)
store i32 0, i32* %27
br label %306
306: ; preds = %345, %299
%307 = load i32, i32* %27
%308 = load i32, i32* %10
%309 = icmp slt i32 %307, %308
br i1 %309, label %310, label %348
310: ; preds = %306
%311 = load i32, i32* %27
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds float, float* %47, i64 %312
%314 = load float, float* %313
store float %314, float* %26
%315 = load float, float* %26
%316 = fcmp ogt float %315, 2.550000e+02
br i1 %316, label %317, label %324
317: ; preds = %310
%318 = load i8*, i8** %25
%319 = load i32, i32* %9
%320 = load i32, i32* %27
%321 = mul nsw i32 %319, %320
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds i8, i8* %318, i64 %322
store i8 -1, i8* %323
br label %344
324: ; preds = %310
%325 = load float, float* %26
%326 = fcmp olt float %325, 0.000000e+00
br i1 %326, label %327, label %334
327: ; preds = %324
%328 = load i8*, i8** %25
%329 = load i32, i32* %9
%330 = load i32, i32* %27
%331 = mul nsw i32 %329, %330
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds i8, i8* %328, i64 %332
store i8 0, i8* %333
br label %343
334: ; preds = %324
%335 = load float, float* %26
%336 = fptoui float %335 to i8
%337 = load i8*, i8** %25
%338 = load i32, i32* %9
%339 = load i32, i32* %27
%340 = mul nsw i32 %338, %339
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i8, i8* %337, i64 %341
store i8 %336, i8* %342
br label %343
343: ; preds = %334, %327
br label %344
344: ; preds = %343, %317
br label %345
345: ; preds = %344
%346 = load i32, i32* %27
%347 = add nsw i32 %346, 1
store i32 %347, i32* %27
br label %306
348: ; preds = %306
br label %349
349: ; preds = %348
%350 = load i32, i32* %24
%351 = add nsw i32 %350, 1
store i32 %351, i32* %24
br label %271
352: ; preds = %271
br label %353
353: ; preds = %352, %267
%354 = load i8*, i8** %15
ret void
}

LLVM IR (-O2):
define void @upsample_component_lanczos(i8* nocapture %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6) {
%8 = zext i32 %1 to i64
%9 = alloca float, i64 %8
%10 = alloca float, i64 %8
%11 = alloca float, i64 %8
%12 = zext i32 %2 to i64
%13 = alloca float, i64 %12
%14 = alloca float, i64 %12
%15 = alloca float, i64 %12
%16 = mul i32 %5, 6
%17 = or i32 %16, 1
%18 = zext i32 %17 to i64
%19 = alloca float, i64 %18
%20 = mul i32 %6, 6
%21 = or i32 %20, 1
%22 = zext i32 %21 to i64
%23 = alloca float, i64 %22
%24 = mul nsw i32 %5, 3
%25 = mul nsw i32 %6, 3
%26 = icmp sgt i32 %17, 0
br i1 %26, label %27, label %54
27: ; preds = %7
%28 = sitofp i32 %5 to float
%29 = zext i32 %24 to i64
br label %30
30: ; preds = %27, %51
%31 = phi i64 [ 0, %27 ], [ %52, %51 ]
%32 = icmp eq i64 %31, %29
br i1 %32, label %51, label %33
33: ; preds = %30
%34 = trunc i64 %31 to i32
%35 = sub nsw i32 %34, %24
%36 = sitofp i32 %35 to float
%37 = fdiv float %36, %28
%38 = fpext float %37 to x86_fp80
%39 = fmul x86_fp80 %38, 0xK4000C90FDAA22168C235
%40 = tail call i32 @sin(x86_fp80 %39)
%41 = mul nsw i32 %40, 3
%42 = fmul x86_fp80 %38, 0xK3FFF860A91C16B9B2C23
%43 = tail call i32 @sin(x86_fp80 %42)
%44 = mul nsw i32 %41, %43
%45 = sitofp i32 %44 to x86_fp80
%46 = fmul x86_fp80 %38, 0xK40029DE9E64DF22EF2D3
%47 = fmul x86_fp80 %46, %38
%48 = fdiv x86_fp80 %45, %47
%49 = fptrunc x86_fp80 %48 to float
%50 = getelementptr inbounds float, float* %19, i64 %31
store float %49, float* %50
br label %51
51: ; preds = %30, %33
%52 = add nuw nsw i64 %31, 1
%53 = icmp eq i64 %52, %18
br i1 %53, label %54, label %30
54: ; preds = %51, %7
%55 = sext i32 %24 to i64
%56 = getelementptr inbounds float, float* %19, i64 %55
store float 1.000000e+00, float* %56
%57 = icmp sgt i32 %21, 0
br i1 %57, label %58, label %85
58: ; preds = %54
%59 = sitofp i32 %6 to float
%60 = zext i32 %25 to i64
br label %61
61: ; preds = %58, %82
%62 = phi i64 [ 0, %58 ], [ %83, %82 ]
%63 = icmp eq i64 %62, %60
br i1 %63, label %82, label %64
64: ; preds = %61
%65 = trunc i64 %62 to i32
%66 = sub nsw i32 %65, %25
%67 = sitofp i32 %66 to float
%68 = fdiv float %67, %59
%69 = fpext float %68 to x86_fp80
%70 = fmul x86_fp80 %69, 0xK4000C90FDAA22168C235
%71 = tail call i32 @sin(x86_fp80 %70)
%72 = mul nsw i32 %71, 3
%73 = fmul x86_fp80 %69, 0xK3FFF860A91C16B9B2C23
%74 = tail call i32 @sin(x86_fp80 %73)
%75 = mul nsw i32 %72, %74
%76 = sitofp i32 %75 to x86_fp80
%77 = fmul x86_fp80 %69, 0xK40029DE9E64DF22EF2D3
%78 = fmul x86_fp80 %77, %69
%79 = fdiv x86_fp80 %76, %78
%80 = fptrunc x86_fp80 %79 to float
%81 = getelementptr inbounds float, float* %23, i64 %62
store float %80, float* %81
br label %82
82: ; preds = %61, %64
%83 = add nuw nsw i64 %62, 1
%84 = icmp eq i64 %83, %22
br i1 %84, label %85, label %61
85: ; preds = %82, %54
%86 = sext i32 %25 to i64
%87 = getelementptr inbounds float, float* %23, i64 %86
store float 1.000000e+00, float* %87
%88 = tail call i32 @return_downscaled_array_len(i32 %1, i32 %3, i32 %5)
%89 = tail call i32 @return_downscaled_array_len(i32 %2, i32 %4, i32 %6)
%90 = icmp ne i32 %5, 1
%91 = icmp ne i32 %3, 0
%92 = or i1 %91, %90
%93 = icmp sgt i32 %89, 0
%94 = select i1 %92, i1 %93, i1 false
br i1 %94, label %95, label %256
95: ; preds = %85
%96 = icmp sgt i32 %88, 0
%97 = icmp sgt i32 %1, 0
%98 = sext i32 %1 to i64
%99 = zext i32 %89 to i64
%100 = zext i32 %88 to i64
%101 = and i64 %100, 4294967288
%102 = add nsw i64 %101, -8
%103 = lshr exact i64 %102, 3
%104 = add nuw nsw i64 %103, 1
%105 = and i64 %8, 4294967292
%106 = add nsw i64 %105, -4
%107 = lshr exact i64 %106, 2
%108 = add nuw nsw i64 %107, 1
%109 = icmp ult i32 %88, 8
%110 = and i64 %100, 4294967288
%111 = and i64 %104, 1
%112 = icmp eq i64 %102, 0
%113 = and i64 %104, 4611686018427387902
%114 = icmp eq i64 %111, 0
%115 = icmp eq i64 %110, %100
%116 = icmp ult i32 %1, 4
%117 = and i64 %8, 4294967292
%118 = and i64 %108, 1
%119 = icmp eq i64 %106, 0
%120 = and i64 %108, 9223372036854775806
%121 = icmp eq i64 %118, 0
%122 = icmp eq i64 %117, %8
br label %123
123: ; preds = %95, %253
%124 = phi i64 [ 0, %95 ], [ %254, %253 ]
%125 = mul nsw i64 %124, %98
%126 = getelementptr inbounds i8, i8* %0, i64 %125
br i1 %96, label %127, label %186
127: ; preds = %123
br i1 %109, label %176, label %128
128: ; preds = %127
br i1 %112, label %160, label %129
129: ; preds = %128, %129
%130 = phi i64 [ %157, %129 ], [ 0, %128 ]
%131 = phi i64 [ %158, %129 ], [ 0, %128 ]
%132 = getelementptr inbounds i8, i8* %126, i64 %130
%133 = bitcast i8* %132 to <4 x i8>*
%134 = load <4 x i8>, <4 x i8>* %133
%135 = getelementptr inbounds i8, i8* %132, i64 4
%136 = bitcast i8* %135 to <4 x i8>*
%137 = load <4 x i8>, <4 x i8>* %136
%138 = uitofp <4 x i8> %134 to <4 x float>
%139 = uitofp <4 x i8> %137 to <4 x float>
%140 = getelementptr inbounds float, float* %11, i64 %130
%141 = bitcast float* %140 to <4 x float>*
store <4 x float> %138, <4 x float>* %141
%142 = getelementptr inbounds float, float* %140, i64 4
%143 = bitcast float* %142 to <4 x float>*
store <4 x float> %139, <4 x float>* %143
%144 = or i64 %130, 8
%145 = getelementptr inbounds i8, i8* %126, i64 %144
%146 = bitcast i8* %145 to <4 x i8>*
%147 = load <4 x i8>, <4 x i8>* %146
%148 = getelementptr inbounds i8, i8* %145, i64 4
%149 = bitcast i8* %148 to <4 x i8>*
%150 = load <4 x i8>, <4 x i8>* %149
%151 = uitofp <4 x i8> %147 to <4 x float>
%152 = uitofp <4 x i8> %150 to <4 x float>
%153 = getelementptr inbounds float, float* %11, i64 %144
%154 = bitcast float* %153 to <4 x float>*
store <4 x float> %151, <4 x float>* %154
%155 = getelementptr inbounds float, float* %153, i64 4
%156 = bitcast float* %155 to <4 x float>*
store <4 x float> %152, <4 x float>* %156
%157 = add nuw i64 %130, 16
%158 = add i64 %131, 2
%159 = icmp eq i64 %158, %113
br i1 %159, label %160, label %129
160: ; preds = %129, %128
%161 = phi i64 [ 0, %128 ], [ %157, %129 ]
br i1 %114, label %175, label %162
162: ; preds = %160
%163 = getelementptr inbounds i8, i8* %126, i64 %161
%164 = bitcast i8* %163 to <4 x i8>*
%165 = load <4 x i8>, <4 x i8>* %164
%166 = getelementptr inbounds i8, i8* %163, i64 4
%167 = bitcast i8* %166 to <4 x i8>*
%168 = load <4 x i8>, <4 x i8>* %167
%169 = uitofp <4 x i8> %165 to <4 x float>
%170 = uitofp <4 x i8> %168 to <4 x float>
%171 = getelementptr inbounds float, float* %11, i64 %161
%172 = bitcast float* %171 to <4 x float>*
store <4 x float> %169, <4 x float>* %172
%173 = getelementptr inbounds float, float* %171, i64 4
%174 = bitcast float* %173 to <4 x float>*
store <4 x float> %170, <4 x float>* %174
br label %175
175: ; preds = %160, %162
br i1 %115, label %186, label %176
176: ; preds = %127, %175
%177 = phi i64 [ 0, %127 ], [ %110, %175 ]
br label %178
178: ; preds = %176, %178
%179 = phi i64 [ %184, %178 ], [ %177, %176 ]
%180 = getelementptr inbounds i8, i8* %126, i64 %179
%181 = load i8, i8* %180
%182 = uitofp i8 %181 to float
%183 = getelementptr inbounds float, float* %11, i64 %179
store float %182, float* %183
%184 = add nuw nsw i64 %179, 1
%185 = icmp eq i64 %184, %100
br i1 %185, label %186, label %178
186: ; preds = %178, %175, %123
%187 = call i32 @upsample_component_line_lanczos(float* %11, float* %9, float* %10, float* %19, i32 %17, i32 %1, i32 %3, i32 %5, i32 %88)
br i1 %97, label %188, label %253
188: ; preds = %186
br i1 %116, label %237, label %189
189: ; preds = %188
br i1 %119, label %221, label %190
190: ; preds = %189, %190
%191 = phi i64 [ %218, %190 ], [ 0, %189 ]
%192 = phi i64 [ %219, %190 ], [ 0, %189 ]
%193 = getelementptr inbounds float, float* %9, i64 %191
%194 = bitcast float* %193 to <4 x float>*
%195 = load <4 x float>, <4 x float>* %194
%196 = fcmp ogt <4 x float> %195, <float 2.550000e+02, float 2.550000e+02, float 2.550000e+02, float 2.550000e+02>
%197 = fcmp uge <4 x float> %195, zeroinitializer
%198 = or <4 x i1> %196, %197
%199 = fcmp oge <4 x float> %195, <float 2.550000e+02, float 2.550000e+02, float 2.550000e+02, float 2.550000e+02>
%200 = select <4 x i1> %199, <4 x float> <float 2.550000e+02, float 2.550000e+02, float 2.550000e+02, float 2.550000e+02>, <4 x float> %195
%201 = fptoui <4 x float> %200 to <4 x i8>
%202 = select <4 x i1> %198, <4 x i8> %201, <4 x i8> zeroinitializer
%203 = getelementptr inbounds i8, i8* %126, i64 %191
%204 = bitcast i8* %203 to <4 x i8>*
store <4 x i8> %202, <4 x i8>* %204
%205 = or i64 %191, 4
%206 = getelementptr inbounds float, float* %9, i64 %205
%207 = bitcast float* %206 to <4 x float>*
%208 = load <4 x float>, <4 x float>* %207
%209 = fcmp ogt <4 x float> %208, <float 2.550000e+02, float 2.550000e+02, float 2.550000e+02, float 2.550000e+02>
%210 = fcmp uge <4 x float> %208, zeroinitializer
%211 = or <4 x i1> %209, %210
%212 = fcmp oge <4 x float> %208, <float 2.550000e+02, float 2.550000e+02, float 2.550000e+02, float 2.550000e+02>
%213 = select <4 x i1> %212, <4 x float> <float 2.550000e+02, float 2.550000e+02, float 2.550000e+02, float 2.550000e+02>, <4 x float> %208
%214 = fptoui <4 x float> %213 to <4 x i8>
%215 = select <4 x i1> %211, <4 x i8> %214, <4 x i8> zeroinitializer
%216 = getelementptr inbounds i8, i8* %126, i64 %205
%217 = bitcast i8* %216 to <4 x i8>*
store <4 x i8> %215, <4 x i8>* %217
%218 = add nuw i64 %191, 8
%219 = add i64 %192, 2
%220 = icmp eq i64 %219, %120
br i1 %220, label %221, label %190
221: ; preds = %190, %189
%222 = phi i64 [ 0, %189 ], [ %218, %190 ]
br i1 %121, label %236, label %223
223: ; preds = %221
%224 = getelementptr inbounds float, float* %9, i64 %222
%225 = bitcast float* %224 to <4 x float>*
%226 = load <4 x float>, <4 x float>* %225
%227 = fcmp ogt <4 x float> %226, <float 2.550000e+02, float 2.550000e+02, float 2.550000e+02, float 2.550000e+02>
%228 = fcmp uge <4 x float> %226, zeroinitializer
%229 = or <4 x i1> %227, %228
%230 = fcmp oge <4 x float> %226, <float 2.550000e+02, float 2.550000e+02, float 2.550000e+02, float 2.550000e+02>
%231 = select <4 x i1> %230, <4 x float> <float 2.550000e+02, float 2.550000e+02, float 2.550000e+02, float 2.550000e+02>, <4 x float> %226
%232 = fptoui <4 x float> %231 to <4 x i8>
%233 = select <4 x i1> %229, <4 x i8> %232, <4 x i8> zeroinitializer
%234 = getelementptr inbounds i8, i8* %126, i64 %222
%235 = bitcast i8* %234 to <4 x i8>*
store <4 x i8> %233, <4 x i8>* %235
br label %236
236: ; preds = %221, %223
br i1 %122, label %253, label %237
237: ; preds = %188, %236
%238 = phi i64 [ 0, %188 ], [ %117, %236 ]
br label %239
239: ; preds = %237, %248
%240 = phi i64 [ %251, %248 ], [ %238, %237 ]
%241 = getelementptr inbounds float, float* %9, i64 %240
%242 = load float, float* %241
%243 = fcmp ogt float %242, 2.550000e+02
br i1 %243, label %248, label %244
244: ; preds = %239
%245 = fcmp olt float %242, 0.000000e+00
br i1 %245, label %248, label %246
246: ; preds = %244
%247 = fptoui float %242 to i8
br label %248
248: ; preds = %244, %239, %246
%249 = phi i8 [ %247, %246 ], [ -1, %239 ], [ 0, %244 ]
%250 = getelementptr inbounds i8, i8* %126, i64 %240
store i8 %249, i8* %250
%251 = add nuw nsw i64 %240, 1
%252 = icmp eq i64 %251, %8
br i1 %252, label %253, label %239
253: ; preds = %248, %236, %186
%254 = add nuw nsw i64 %124, 1
%255 = icmp eq i64 %254, %99
br i1 %255, label %256, label %123
256: ; preds = %253, %85
%257 = icmp ne i32 %6, 1
%258 = icmp ne i32 %4, 0
%259 = or i1 %258, %257
%260 = icmp sgt i32 %1, 0
%261 = and i1 %259, %260
br i1 %261, label %262, label %370
262: ; preds = %256
%263 = icmp sgt i32 %2, 0
%264 = zext i32 %1 to i64
%265 = zext i32 %89 to i64
%266 = add nsw i64 %265, -1
%267 = and i64 %265, 3
%268 = icmp ult i64 %266, 3
%269 = and i64 %265, 4294967292
%270 = icmp eq i64 %267, 0
%271 = and i64 %12, 1
%272 = icmp eq i32 %2, 1
%273 = and i64 %12, 4294967294
%274 = icmp eq i64 %271, 0
br label %275
275: ; preds = %262, %367
%276 = phi i64 [ 0, %262 ], [ %368, %367 ]
%277 = getelementptr inbounds i8, i8* %0, i64 %276
br i1 %93, label %278, label %321
278: ; preds = %275
br i1 %268, label %308, label %279
279: ; preds = %278, %279
%280 = phi i64 [ %305, %279 ], [ 0, %278 ]
%281 = phi i64 [ %306, %279 ], [ 0, %278 ]
%282 = mul nsw i64 %280, %264
%283 = getelementptr inbounds i8, i8* %277, i64 %282
%284 = load i8, i8* %283
%285 = uitofp i8 %284 to float
%286 = getelementptr inbounds float, float* %15, i64 %280
store float %285, float* %286
%287 = or i64 %280, 1
%288 = mul nsw i64 %287, %264
%289 = getelementptr inbounds i8, i8* %277, i64 %288
%290 = load i8, i8* %289
%291 = uitofp i8 %290 to float
%292 = getelementptr inbounds float, float* %15, i64 %287
store float %291, float* %292
%293 = or i64 %280, 2
%294 = mul nsw i64 %293, %264
%295 = getelementptr inbounds i8, i8* %277, i64 %294
%296 = load i8, i8* %295
%297 = uitofp i8 %296 to float
%298 = getelementptr inbounds float, float* %15, i64 %293
store float %297, float* %298
%299 = or i64 %280, 3
%300 = mul nsw i64 %299, %264
%301 = getelementptr inbounds i8, i8* %277, i64 %300
%302 = load i8, i8* %301
%303 = uitofp i8 %302 to float
%304 = getelementptr inbounds float, float* %15, i64 %299
store float %303, float* %304
%305 = add nuw nsw i64 %280, 4
%306 = add i64 %281, 4
%307 = icmp eq i64 %306, %269
br i1 %307, label %308, label %279
308: ; preds = %279, %278
%309 = phi i64 [ 0, %278 ], [ %305, %279 ]
br i1 %270, label %321, label %310
310: ; preds = %308, %310
%311 = phi i64 [ %318, %310 ], [ %309, %308 ]
%312 = phi i64 [ %319, %310 ], [ 0, %308 ]
%313 = mul nsw i64 %311, %264
%314 = getelementptr inbounds i8, i8* %277, i64 %313
%315 = load i8, i8* %314
%316 = uitofp i8 %315 to float
%317 = getelementptr inbounds float, float* %15, i64 %311
store float %316, float* %317
%318 = add nuw nsw i64 %311, 1
%319 = add i64 %312, 1
%320 = icmp eq i64 %319, %267
br i1 %320, label %321, label %310
321: ; preds = %308, %310, %275
%322 = call i32 @upsample_component_line_lanczos(float* %15, float* %13, float* %14, float* %23, i32 %21, i32 %2, i32 %4, i32 %6, i32 %89)
br i1 %263, label %323, label %367
323: ; preds = %321
br i1 %272, label %353, label %324
324: ; preds = %323, %346
%325 = phi i64 [ %350, %346 ], [ 0, %323 ]
%326 = phi i64 [ %351, %346 ], [ 0, %323 ]
%327 = getelementptr inbounds float, float* %13, i64 %325
%328 = load float, float* %327
%329 = fcmp ogt float %328, 2.550000e+02
br i1 %329, label %334, label %330
330: ; preds = %324
%331 = fcmp olt float %328, 0.000000e+00
br i1 %331, label %334, label %332
332: ; preds = %330
%333 = fptoui float %328 to i8
br label %334
334: ; preds = %330, %324, %332
%335 = phi i8 [ %333, %332 ], [ -1, %324 ], [ 0, %330 ]
%336 = mul nsw i64 %325, %264
%337 = getelementptr inbounds i8, i8* %277, i64 %336
store i8 %335, i8* %337
%338 = or i64 %325, 1
%339 = getelementptr inbounds float, float* %13, i64 %338
%340 = load float, float* %339
%341 = fcmp ogt float %340, 2.550000e+02
br i1 %341, label %346, label %342
342: ; preds = %334
%343 = fcmp olt float %340, 0.000000e+00
br i1 %343, label %346, label %344
344: ; preds = %342
%345 = fptoui float %340 to i8
br label %346
346: ; preds = %344, %342, %334
%347 = phi i8 [ %345, %344 ], [ -1, %334 ], [ 0, %342 ]
%348 = mul nsw i64 %338, %264
%349 = getelementptr inbounds i8, i8* %277, i64 %348
store i8 %347, i8* %349
%350 = add nuw nsw i64 %325, 2
%351 = add i64 %326, 2
%352 = icmp eq i64 %351, %273
br i1 %352, label %353, label %324
353: ; preds = %346, %323
%354 = phi i64 [ 0, %323 ], [ %350, %346 ]
br i1 %274, label %367, label %355
355: ; preds = %353
%356 = getelementptr inbounds float, float* %13, i64 %354
%357 = load float, float* %356
%358 = fcmp ogt float %357, 2.550000e+02
br i1 %358, label %363, label %359
359: ; preds = %355
%360 = fcmp olt float %357, 0.000000e+00
br i1 %360, label %363, label %361
361: ; preds = %359
%362 = fptoui float %357 to i8
br label %363
363: ; preds = %361, %359, %355
%364 = phi i8 [ %362, %361 ], [ -1, %355 ], [ 0, %359 ]
%365 = mul nsw i64 %354, %264
%366 = getelementptr inbounds i8, i8* %277, i64 %365
store i8 %364, i8* %366
br label %367
367: ; preds = %363, %353, %321
%368 = add nuw nsw i64 %276, 1
%369 = icmp eq i64 %368, %8
br i1 %369, label %370, label %275
370: ; preds = %367, %256
ret void
}