void upsample_component_line_lanczos(const float *x_in_buff, float *x_out_buff,
                                     float *weight_x_out_buff,
                                     const float *x_contrib,
                                     const int x_contrib_size, const int width,
                                     const int xpos, const int xstep,
                                     const int compressed_width) {
  int i;
  int rpos;
  int wpos;
  int cpos;
  int weight_shift;
  weight_shift = 0 - ((x_contrib_size - 1) / 2);
  if (xstep > 1) {
    for (i = 0; i < width; i++)
      x_out_buff[i] = weight_x_out_buff[i] = 0;
    for (rpos = 0; rpos < compressed_width; rpos++) {
      wpos = (rpos * xstep) + weight_shift;
      for (cpos = 0; cpos < x_contrib_size; cpos++) {
        if ((wpos >= 0) && (wpos < width)) {
          weight_x_out_buff[wpos] += x_contrib[cpos];
          x_out_buff[wpos] += x_in_buff[rpos] * x_contrib[cpos];
        }
        wpos++;
      }
    }
    for (i = 0; i < width; i++)
      x_out_buff[i] = x_out_buff[i] / weight_x_out_buff[i];
  }
}


x86 assembly (clang, -O0):
<upsample_component_line_lanczos>:
push   %rbp
mov    %rsp,%rbp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x1,0x18(%rbp)
jle    129a <upsample_component_line_lanczos+0x19a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1187 <upsample_component_line_lanczos+0x87>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    114d <upsample_component_line_lanczos+0x4d>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    124d <upsample_component_line_lanczos+0x14d>
mov    -0x30(%rbp),%eax
imul   0x18(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    123a <upsample_component_line_lanczos+0x13a>
cmpl   $0x0,-0x34(%rbp)
jl     1223 <upsample_component_line_lanczos+0x123>
mov    -0x34(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1223 <upsample_component_line_lanczos+0x123>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11ae <upsample_component_line_lanczos+0xae>
jmp    123f <upsample_component_line_lanczos+0x13f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    118e <upsample_component_line_lanczos+0x8e>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1295 <upsample_component_line_lanczos+0x195>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1254 <upsample_component_line_lanczos+0x154>
jmp    129a <upsample_component_line_lanczos+0x19a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<upsample_component_line_lanczos>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x38(%rsp),%r10d
cmp    $0x2,%r10d
jl     1438 <upsample_component_line_lanczos+0x338>
mov    0x40(%rsp),%r11d
mov    %r9d,%r15d
test   %r9d,%r9d
jle    12b9 <upsample_component_line_lanczos+0x1b9>
cmp    $0x8,%r9d
jb     1149 <upsample_component_line_lanczos+0x49>
lea    (%rsi,%r15,4),%rax
cmp    %rdx,%rax
jbe    11dc <upsample_component_line_lanczos+0xdc>
lea    (%rdx,%r15,4),%rax
cmp    %rsi,%rax
jbe    11dc <upsample_component_line_lanczos+0xdc>
xor    %ebx,%ebx
mov    %rbx,%r14
not    %r14
add    %r15,%r14
mov    %r15,%rax
and    $0x3,%rax
je     1178 <upsample_component_line_lanczos+0x78>
nopl   (%rax)
movl   $0x0,(%rdx,%rbx,4)
movl   $0x0,(%rsi,%rbx,4)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rax
jne    1160 <upsample_component_line_lanczos+0x60>
cmp    $0x3,%r14
jb     12b9 <upsample_component_line_lanczos+0x1b9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x0,(%rdx,%rbx,4)
movl   $0x0,(%rsi,%rbx,4)
movl   $0x0,0x4(%rdx,%rbx,4)
movl   $0x0,0x4(%rsi,%rbx,4)
movl   $0x0,0x8(%rdx,%rbx,4)
movl   $0x0,0x8(%rsi,%rbx,4)
movl   $0x0,0xc(%rdx,%rbx,4)
movl   $0x0,0xc(%rsi,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%r15
jne    1190 <upsample_component_line_lanczos+0x90>
jmp    12b9 <upsample_component_line_lanczos+0x1b9>
mov    %r15d,%ebx
and    $0xfffffff8,%ebx
lea    -0x8(%rbx),%rax
mov    %rax,%r12
shr    $0x3,%r12
add    $0x1,%r12
mov    %r12d,%r14d
and    $0x3,%r14d
cmp    $0x18,%rax
jae    1202 <upsample_component_line_lanczos+0x102>
xor    %eax,%eax
jmp    1268 <upsample_component_line_lanczos+0x168>
and    $0xfffffffffffffffc,%r12
xor    %eax,%eax
xorps  %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movups %xmm0,(%rdx,%rax,4)
movups %xmm0,0x10(%rdx,%rax,4)
movups %xmm0,(%rsi,%rax,4)
movups %xmm0,0x10(%rsi,%rax,4)
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm0,0x30(%rdx,%rax,4)
movups %xmm0,0x20(%rsi,%rax,4)
movups %xmm0,0x30(%rsi,%rax,4)
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm0,0x50(%rdx,%rax,4)
movups %xmm0,0x40(%rsi,%rax,4)
movups %xmm0,0x50(%rsi,%rax,4)
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm0,0x70(%rdx,%rax,4)
movups %xmm0,0x60(%rsi,%rax,4)
movups %xmm0,0x70(%rsi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r12
jne    1210 <upsample_component_line_lanczos+0x110>
test   %r14,%r14
je     12b0 <upsample_component_line_lanczos+0x1b0>
lea    (%rsi,%rax,4),%r12
add    $0x10,%r12
lea    (%rdx,%rax,4),%r13
add    $0x10,%r13
shl    $0x5,%r14
xor    %eax,%eax
xorps  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movups %xmm0,-0x10(%r13,%rax,1)
movups %xmm0,0x0(%r13,%rax,1)
movups %xmm0,-0x10(%r12,%rax,1)
movups %xmm0,(%r12,%rax,1)
add    $0x20,%rax
cmp    %rax,%r14
jne    1290 <upsample_component_line_lanczos+0x190>
cmp    %r15,%rbx
jne    114b <upsample_component_line_lanczos+0x4b>
test   %r11d,%r11d
jle    1352 <upsample_component_line_lanczos+0x252>
lea    -0x1(%r8),%eax
shr    $0x1f,%eax
add    %r8d,%eax
add    $0xffffffff,%eax
sar    %eax
neg    %eax
mov    %r11d,%r11d
mov    %r8d,%r12d
mov    %eax,%r13d
mov    %r10d,%r10d
xor    %r14d,%r14d
jmp    12fc <upsample_component_line_lanczos+0x1fc>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r14
add    %r10,%r13
cmp    %r11,%r14
je     1352 <upsample_component_line_lanczos+0x252>
test   %r8d,%r8d
jle    12f0 <upsample_component_line_lanczos+0x1f0>
xor    %eax,%eax
jmp    1319 <upsample_component_line_lanczos+0x219>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rax
cmp    %rax,%r12
je     12f0 <upsample_component_line_lanczos+0x1f0>
lea    (%rax,%r13,1),%rbx
test   %ebx,%ebx
js     1310 <upsample_component_line_lanczos+0x210>
cmp    %r9d,%ebx
jge    1310 <upsample_component_line_lanczos+0x210>
movss  (%rcx,%rax,4),%xmm0
mov    %ebx,%ebx
shl    $0x2,%rbx
addss  (%rdx,%rbx,1),%xmm0
movss  %xmm0,(%rdx,%rbx,1)
movss  (%rdi,%r14,4),%xmm0
mulss  (%rcx,%rax,4),%xmm0
addss  (%rsi,%rbx,1),%xmm0
movss  %xmm0,(%rsi,%rbx,1)
jmp    1310 <upsample_component_line_lanczos+0x210>
test   %r9d,%r9d
jle    1438 <upsample_component_line_lanczos+0x338>
cmp    $0x4,%r9d
jb     1373 <upsample_component_line_lanczos+0x273>
lea    (%rdx,%r15,4),%rax
cmp    %rsi,%rax
jbe    13cc <upsample_component_line_lanczos+0x2cc>
lea    (%rsi,%r15,4),%rax
cmp    %rdx,%rax
jbe    13cc <upsample_component_line_lanczos+0x2cc>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
test   $0x1,%r15b
je     1394 <upsample_component_line_lanczos+0x294>
movss  (%rsi,%rcx,4),%xmm0
divss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
or     $0x1,%rcx
add    %r15,%rax
je     1438 <upsample_component_line_lanczos+0x338>
nopl   (%rax)
movss  (%rsi,%rcx,4),%xmm0
divss  (%rdx,%rcx,4),%xmm0
movss  0x4(%rsi,%rcx,4),%xmm1
movss  %xmm0,(%rsi,%rcx,4)
divss  0x4(%rdx,%rcx,4),%xmm1
movss  %xmm1,0x4(%rsi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r15
jne    13a0 <upsample_component_line_lanczos+0x2a0>
jmp    1438 <upsample_component_line_lanczos+0x338>
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rax
mov    %rax,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rax,%rax
je     1442 <upsample_component_line_lanczos+0x342>
mov    %rbx,%rax
and    $0xfffffffffffffffe,%rax
xor    %edi,%edi
nop
movups (%rdx,%rdi,4),%xmm0
movups (%rsi,%rdi,4),%xmm1
divps  %xmm0,%xmm1
movups 0x10(%rsi,%rdi,4),%xmm0
movups %xmm1,(%rsi,%rdi,4)
movups 0x10(%rdx,%rdi,4),%xmm1
divps  %xmm1,%xmm0
movups %xmm0,0x10(%rsi,%rdi,4)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rax
jne    13f0 <upsample_component_line_lanczos+0x2f0>
test   $0x1,%bl
je     142f <upsample_component_line_lanczos+0x32f>
movups (%rsi,%rdi,4),%xmm0
movups (%rdx,%rdi,4),%xmm1
divps  %xmm1,%xmm0
movups %xmm0,(%rsi,%rdi,4)
cmp    %r15,%rcx
jne    1375 <upsample_component_line_lanczos+0x275>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
xor    %edi,%edi
test   $0x1,%bl
jne    1420 <upsample_component_line_lanczos+0x320>
jmp    142f <upsample_component_line_lanczos+0x32f>

LLVM IR (-O0):
define void @upsample_component_line_lanczos(float* %0, float* %1, float* %2, float* %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8) {
%10 = alloca float*
%11 = alloca float*
%12 = alloca float*
%13 = alloca float*
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
store float* %0, float** %10
store float* %1, float** %11
store float* %2, float** %12
store float* %3, float** %13
store i32 %4, i32* %14
store i32 %5, i32* %15
store i32 %6, i32* %16
store i32 %7, i32* %17
store i32 %8, i32* %18
%24 = load i32, i32* %14
%25 = sub nsw i32 %24, 1
%26 = sdiv i32 %25, 2
%27 = sub nsw i32 0, %26
store i32 %27, i32* %23
%28 = load i32, i32* %17
%29 = icmp sgt i32 %28, 1
br i1 %29, label %30, label %132
30: ; preds = %9
store i32 0, i32* %19
br label %31
31: ; preds = %44, %30
%32 = load i32, i32* %19
%33 = load i32, i32* %15
%34 = icmp slt i32 %32, %33
br i1 %34, label %35, label %47
35: ; preds = %31
%36 = load float*, float** %12
%37 = load i32, i32* %19
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds float, float* %36, i64 %38
store float 0.000000e+00, float* %39
%40 = load float*, float** %11
%41 = load i32, i32* %19
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %40, i64 %42
store float 0.000000e+00, float* %43
br label %44
44: ; preds = %35
%45 = load i32, i32* %19
%46 = add nsw i32 %45, 1
store i32 %46, i32* %19
br label %31
47: ; preds = %31
store i32 0, i32* %20
br label %48
48: ; preds = %104, %47
%49 = load i32, i32* %20
%50 = load i32, i32* %18
%51 = icmp slt i32 %49, %50
br i1 %51, label %52, label %107
52: ; preds = %48
%53 = load i32, i32* %20
%54 = load i32, i32* %17
%55 = mul nsw i32 %53, %54
%56 = load i32, i32* %23
%57 = add nsw i32 %55, %56
store i32 %57, i32* %21
store i32 0, i32* %22
br label %58
58: ; preds = %100, %52
%59 = load i32, i32* %22
%60 = load i32, i32* %14
%61 = icmp slt i32 %59, %60
br i1 %61, label %62, label %103
62: ; preds = %58
%63 = load i32, i32* %21
%64 = icmp sge i32 %63, 0
br i1 %64, label %65, label %97
65: ; preds = %62
%66 = load i32, i32* %21
%67 = load i32, i32* %15
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %97
69: ; preds = %65
%70 = load float*, float** %13
%71 = load i32, i32* %22
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %70, i64 %72
%74 = load float, float* %73
%75 = load float*, float** %12
%76 = load i32, i32* %21
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds float, float* %75, i64 %77
%79 = load float, float* %78
%80 = fadd float %79, %74
store float %80, float* %78
%81 = load float*, float** %10
%82 = load i32, i32* %20
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds float, float* %81, i64 %83
%85 = load float, float* %84
%86 = load float*, float** %13
%87 = load i32, i32* %22
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float, float* %86, i64 %88
%90 = load float, float* %89
%91 = load float*, float** %11
%92 = load i32, i32* %21
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds float, float* %91, i64 %93
%95 = load float, float* %94
%96 = call float @llvm.fmuladd.f32(float %85, float %90, float %95)
store float %96, float* %94
br label %97
97: ; preds = %69, %65, %62
%98 = load i32, i32* %21
%99 = add nsw i32 %98, 1
store i32 %99, i32* %21
br label %100
100: ; preds = %97
%101 = load i32, i32* %22
%102 = add nsw i32 %101, 1
store i32 %102, i32* %22
br label %58
103: ; preds = %58
br label %104
104: ; preds = %103
%105 = load i32, i32* %20
%106 = add nsw i32 %105, 1
store i32 %106, i32* %20
br label %48
107: ; preds = %48
store i32 0, i32* %19
br label %108
108: ; preds = %128, %107
%109 = load i32, i32* %19
%110 = load i32, i32* %15
%111 = icmp slt i32 %109, %110
br i1 %111, label %112, label %131
112: ; preds = %108
%113 = load float*, float** %11
%114 = load i32, i32* %19
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds float, float* %113, i64 %115
%117 = load float, float* %116
%118 = load float*, float** %12
%119 = load i32, i32* %19
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds float, float* %118, i64 %120
%122 = load float, float* %121
%123 = fdiv float %117, %122
%124 = load float*, float** %11
%125 = load i32, i32* %19
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds float, float* %124, i64 %126
store float %123, float* %127
br label %128
128: ; preds = %112
%129 = load i32, i32* %19
%130 = add nsw i32 %129, 1
store i32 %130, i32* %19
br label %108
131: ; preds = %108
br label %132
132: ; preds = %131, %9
ret void
}

LLVM IR (-O2):
define void @upsample_component_line_lanczos(float* nocapture %0, float* nocapture %1, float* nocapture %2, float* nocapture %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8) {
%10 = add nsw i32 %4, -1
%11 = sdiv i32 %10, -2
%12 = icmp sgt i32 %7, 1
br i1 %12, label %13, label %250
13: ; preds = %9
%14 = icmp sgt i32 %5, 0
br i1 %14, label %15, label %110
15: ; preds = %13
%16 = zext i32 %5 to i64
%17 = icmp ult i32 %5, 8
br i1 %17, label %93, label %18
18: ; preds = %15
%19 = getelementptr float, float* %2, i64 %16
%20 = getelementptr float, float* %1, i64 %16
%21 = icmp ugt float* %20, %2
%22 = icmp ugt float* %19, %1
%23 = and i1 %21, %22
br i1 %23, label %93, label %24
24: ; preds = %18
%25 = and i64 %16, 4294967288
%26 = add nsw i64 %25, -8
%27 = lshr exact i64 %26, 3
%28 = add nuw nsw i64 %27, 1
%29 = and i64 %28, 3
%30 = icmp ult i64 %26, 24
br i1 %30, label %74, label %31
31: ; preds = %24
%32 = and i64 %28, 4611686018427387900
br label %33
33: ; preds = %33, %31
%34 = phi i64 [ 0, %31 ], [ %71, %33 ]
%35 = phi i64 [ 0, %31 ], [ %72, %33 ]
%36 = getelementptr inbounds float, float* %2, i64 %34
%37 = bitcast float* %36 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %37
%38 = getelementptr inbounds float, float* %36, i64 4
%39 = bitcast float* %38 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %39
%40 = getelementptr inbounds float, float* %1, i64 %34
%41 = bitcast float* %40 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %41
%42 = getelementptr inbounds float, float* %40, i64 4
%43 = bitcast float* %42 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %43
%44 = or i64 %34, 8
%45 = getelementptr inbounds float, float* %2, i64 %44
%46 = bitcast float* %45 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %46
%47 = getelementptr inbounds float, float* %45, i64 4
%48 = bitcast float* %47 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %48
%49 = getelementptr inbounds float, float* %1, i64 %44
%50 = bitcast float* %49 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %50
%51 = getelementptr inbounds float, float* %49, i64 4
%52 = bitcast float* %51 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %52
%53 = or i64 %34, 16
%54 = getelementptr inbounds float, float* %2, i64 %53
%55 = bitcast float* %54 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %55
%56 = getelementptr inbounds float, float* %54, i64 4
%57 = bitcast float* %56 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %57
%58 = getelementptr inbounds float, float* %1, i64 %53
%59 = bitcast float* %58 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %59
%60 = getelementptr inbounds float, float* %58, i64 4
%61 = bitcast float* %60 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %61
%62 = or i64 %34, 24
%63 = getelementptr inbounds float, float* %2, i64 %62
%64 = bitcast float* %63 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %64
%65 = getelementptr inbounds float, float* %63, i64 4
%66 = bitcast float* %65 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %66
%67 = getelementptr inbounds float, float* %1, i64 %62
%68 = bitcast float* %67 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %68
%69 = getelementptr inbounds float, float* %67, i64 4
%70 = bitcast float* %69 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %70
%71 = add nuw i64 %34, 32
%72 = add i64 %35, 4
%73 = icmp eq i64 %72, %32
br i1 %73, label %74, label %33
74: ; preds = %33, %24
%75 = phi i64 [ 0, %24 ], [ %71, %33 ]
%76 = icmp eq i64 %29, 0
br i1 %76, label %91, label %77
77: ; preds = %74, %77
%78 = phi i64 [ %88, %77 ], [ %75, %74 ]
%79 = phi i64 [ %89, %77 ], [ 0, %74 ]
%80 = getelementptr inbounds float, float* %2, i64 %78
%81 = bitcast float* %80 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %81
%82 = getelementptr inbounds float, float* %80, i64 4
%83 = bitcast float* %82 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %83
%84 = getelementptr inbounds float, float* %1, i64 %78
%85 = bitcast float* %84 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %85
%86 = getelementptr inbounds float, float* %84, i64 4
%87 = bitcast float* %86 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %87
%88 = add nuw i64 %78, 8
%89 = add i64 %79, 1
%90 = icmp eq i64 %89, %29
br i1 %90, label %91, label %77
91: ; preds = %77, %74
%92 = icmp eq i64 %25, %16
br i1 %92, label %110, label %93
93: ; preds = %18, %15, %91
%94 = phi i64 [ 0, %18 ], [ 0, %15 ], [ %25, %91 ]
%95 = xor i64 %94, -1
%96 = add nsw i64 %95, %16
%97 = and i64 %16, 3
%98 = icmp eq i64 %97, 0
br i1 %98, label %107, label %99
99: ; preds = %93, %99
%100 = phi i64 [ %104, %99 ], [ %94, %93 ]
%101 = phi i64 [ %105, %99 ], [ 0, %93 ]
%102 = getelementptr inbounds float, float* %2, i64 %100
store float 0.000000e+00, float* %102
%103 = getelementptr inbounds float, float* %1, i64 %100
store float 0.000000e+00, float* %103
%104 = add nuw nsw i64 %100, 1
%105 = add i64 %101, 1
%106 = icmp eq i64 %105, %97
br i1 %106, label %107, label %99
107: ; preds = %99, %93
%108 = phi i64 [ %94, %93 ], [ %104, %99 ]
%109 = icmp ult i64 %96, 3
br i1 %109, label %110, label %116
110: ; preds = %107, %116, %91, %13
%111 = icmp sgt i32 %8, 0
br i1 %111, label %112, label %131
112: ; preds = %110
%113 = icmp sgt i32 %4, 0
%114 = zext i32 %8 to i64
%115 = zext i32 %4 to i64
br label %203
116: ; preds = %107, %116
%117 = phi i64 [ %129, %116 ], [ %108, %107 ]
%118 = getelementptr inbounds float, float* %2, i64 %117
store float 0.000000e+00, float* %118
%119 = getelementptr inbounds float, float* %1, i64 %117
store float 0.000000e+00, float* %119
%120 = add nuw nsw i64 %117, 1
%121 = getelementptr inbounds float, float* %2, i64 %120
store float 0.000000e+00, float* %121
%122 = getelementptr inbounds float, float* %1, i64 %120
store float 0.000000e+00, float* %122
%123 = add nuw nsw i64 %117, 2
%124 = getelementptr inbounds float, float* %2, i64 %123
store float 0.000000e+00, float* %124
%125 = getelementptr inbounds float, float* %1, i64 %123
store float 0.000000e+00, float* %125
%126 = add nuw nsw i64 %117, 3
%127 = getelementptr inbounds float, float* %2, i64 %126
store float 0.000000e+00, float* %127
%128 = getelementptr inbounds float, float* %1, i64 %126
store float 0.000000e+00, float* %128
%129 = add nuw nsw i64 %117, 4
%130 = icmp eq i64 %129, %16
br i1 %130, label %110, label %116
131: ; preds = %232, %110
br i1 %14, label %132, label %250
132: ; preds = %131
%133 = zext i32 %5 to i64
%134 = icmp ult i32 %5, 4
br i1 %134, label %187, label %135
135: ; preds = %132
%136 = getelementptr float, float* %1, i64 %133
%137 = getelementptr float, float* %2, i64 %133
%138 = icmp ugt float* %137, %1
%139 = icmp ugt float* %136, %2
%140 = and i1 %138, %139
br i1 %140, label %187, label %141
141: ; preds = %135
%142 = and i64 %133, 4294967292
%143 = add nsw i64 %142, -4
%144 = lshr exact i64 %143, 2
%145 = add nuw nsw i64 %144, 1
%146 = and i64 %145, 1
%147 = icmp eq i64 %143, 0
br i1 %147, label %173, label %148
148: ; preds = %141
%149 = and i64 %145, 9223372036854775806
br label %150
150: ; preds = %150, %148
%151 = phi i64 [ 0, %148 ], [ %170, %150 ]
%152 = phi i64 [ 0, %148 ], [ %171, %150 ]
%153 = getelementptr inbounds float, float* %1, i64 %151
%154 = bitcast float* %153 to <4 x float>*
%155 = load <4 x float>, <4 x float>* %154
%156 = getelementptr inbounds float, float* %2, i64 %151
%157 = bitcast float* %156 to <4 x float>*
%158 = load <4 x float>, <4 x float>* %157
%159 = fdiv <4 x float> %155, %158
%160 = bitcast float* %153 to <4 x float>*
store <4 x float> %159, <4 x float>* %160
%161 = or i64 %151, 4
%162 = getelementptr inbounds float, float* %1, i64 %161
%163 = bitcast float* %162 to <4 x float>*
%164 = load <4 x float>, <4 x float>* %163
%165 = getelementptr inbounds float, float* %2, i64 %161
%166 = bitcast float* %165 to <4 x float>*
%167 = load <4 x float>, <4 x float>* %166
%168 = fdiv <4 x float> %164, %167
%169 = bitcast float* %162 to <4 x float>*
store <4 x float> %168, <4 x float>* %169
%170 = add nuw i64 %151, 8
%171 = add i64 %152, 2
%172 = icmp eq i64 %171, %149
br i1 %172, label %173, label %150
173: ; preds = %150, %141
%174 = phi i64 [ 0, %141 ], [ %170, %150 ]
%175 = icmp eq i64 %146, 0
br i1 %175, label %185, label %176
176: ; preds = %173
%177 = getelementptr inbounds float, float* %1, i64 %174
%178 = bitcast float* %177 to <4 x float>*
%179 = load <4 x float>, <4 x float>* %178
%180 = getelementptr inbounds float, float* %2, i64 %174
%181 = bitcast float* %180 to <4 x float>*
%182 = load <4 x float>, <4 x float>* %181
%183 = fdiv <4 x float> %179, %182
%184 = bitcast float* %177 to <4 x float>*
store <4 x float> %183, <4 x float>* %184
br label %185
185: ; preds = %173, %176
%186 = icmp eq i64 %142, %133
br i1 %186, label %250, label %187
187: ; preds = %135, %132, %185
%188 = phi i64 [ 0, %135 ], [ 0, %132 ], [ %142, %185 ]
%189 = xor i64 %188, -1
%190 = and i64 %133, 1
%191 = icmp eq i64 %190, 0
br i1 %191, label %199, label %192
192: ; preds = %187
%193 = getelementptr inbounds float, float* %1, i64 %188
%194 = load float, float* %193
%195 = getelementptr inbounds float, float* %2, i64 %188
%196 = load float, float* %195
%197 = fdiv float %194, %196
store float %197, float* %193
%198 = or i64 %188, 1
br label %199
199: ; preds = %192, %187
%200 = phi i64 [ %188, %187 ], [ %198, %192 ]
%201 = sub nsw i64 0, %133
%202 = icmp eq i64 %189, %201
br i1 %202, label %250, label %235
203: ; preds = %112, %232
%204 = phi i64 [ 0, %112 ], [ %233, %232 ]
br i1 %113, label %205, label %232
205: ; preds = %203
%206 = trunc i64 %204 to i32
%207 = mul nsw i32 %206, %7
%208 = add nsw i32 %207, %11
%209 = getelementptr inbounds float, float* %0, i64 %204
br label %210
210: ; preds = %205, %228
%211 = phi i64 [ 0, %205 ], [ %230, %228 ]
%212 = phi i32 [ %208, %205 ], [ %229, %228 ]
%213 = icmp sgt i32 %212, -1
%214 = icmp slt i32 %212, %5
%215 = and i1 %213, %214
br i1 %215, label %216, label %228
216: ; preds = %210
%217 = getelementptr inbounds float, float* %3, i64 %211
%218 = load float, float* %217
%219 = zext i32 %212 to i64
%220 = getelementptr inbounds float, float* %2, i64 %219
%221 = load float, float* %220
%222 = fadd float %218, %221
store float %222, float* %220
%223 = load float, float* %209
%224 = load float, float* %217
%225 = getelementptr inbounds float, float* %1, i64 %219
%226 = load float, float* %225
%227 = tail call float @llvm.fmuladd.f32(float %223, float %224, float %226)
store float %227, float* %225
br label %228
228: ; preds = %216, %210
%229 = add nsw i32 %212, 1
%230 = add nuw nsw i64 %211, 1
%231 = icmp eq i64 %230, %115
br i1 %231, label %232, label %210
232: ; preds = %228, %203
%233 = add nuw nsw i64 %204, 1
%234 = icmp eq i64 %233, %114
br i1 %234, label %131, label %203
235: ; preds = %199, %235
%236 = phi i64 [ %248, %235 ], [ %200, %199 ]
%237 = getelementptr inbounds float, float* %1, i64 %236
%238 = load float, float* %237
%239 = getelementptr inbounds float, float* %2, i64 %236
%240 = load float, float* %239
%241 = fdiv float %238, %240
store float %241, float* %237
%242 = add nuw nsw i64 %236, 1
%243 = getelementptr inbounds float, float* %1, i64 %242
%244 = load float, float* %243
%245 = getelementptr inbounds float, float* %2, i64 %242
%246 = load float, float* %245
%247 = fdiv float %244, %246
store float %247, float* %243
%248 = add nuw nsw i64 %236, 2
%249 = icmp eq i64 %248, %133
br i1 %249, label %250, label %235
250: ; preds = %199, %235, %185, %131, %9
ret void
}